From 7abe6a5b4ab10ae460ac79169f99842122a203d0 Mon Sep 17 00:00:00 2001 From: Evgeny Gerashchenko Date: Fri, 11 Oct 2013 21:43:40 +0400 Subject: [PATCH] Big refactoring. Migrating to package views and fragments. --- .../org/jetbrains/jet/codegen/AsmUtil.java | 2 +- .../jetbrains/jet/codegen/CodegenUtil.java | 4 +- .../jet/codegen/ExpressionCodegen.java | 2 +- .../jet/codegen/FunctionCodegen.java | 14 +- .../jet/codegen/FunctionTypesUtil.java | 2 +- .../codegen/ImplementationBodyCodegen.java | 2 +- .../jet/codegen/NamespaceCodegen.java | 43 ++-- .../jet/codegen/NamespacePartCodegen.java | 8 +- .../jet/codegen/PropertyCodegen.java | 6 +- .../binding/CodegenAnnotatingVisitor.java | 4 +- .../jet/codegen/binding/CodegenBinding.java | 28 ++- .../jet/codegen/context/CodegenContext.java | 10 +- ...espaceContext.java => PackageContext.java} | 9 +- ...Context.java => PackageFacadeContext.java} | 8 +- .../jet/codegen/state/GenerationState.java | 8 +- .../jet/codegen/state/JetTypeMapper.java | 133 +++++------- .../CliLightClassGenerationSupport.java | 19 +- .../jet/cli/jvm/repl/ReplInterpreter.java | 10 +- .../di/InjectorForJavaDescriptorResolver.java | 32 +-- .../di/InjectorForTopDownAnalyzerForJvm.java | 40 ++-- .../resolve/java/AnalyzerFacadeForJVM.java | 40 ++-- .../lang/resolve/java/JavaBindingContext.java | 4 +- .../resolver/TraceBasedJavaResolverCache.java | 15 +- .../serialization/DescriptorFinder.java | 7 +- .../serialization/DescriptorSerializer.java | 10 +- .../descriptors/serialization/NameTable.java | 13 +- .../descriptors/DeserializedMemberScope.java | 2 +- .../DeserializedPackageMemberScope.java | 18 +- .../di/InjectorForTopDownAnalyzerBasic.java | 8 +- .../jet/lang/psi/JetNamespaceHeader.java | 4 +- .../jet/lang/resolve/BindingContext.java | 14 +- .../jet/lang/resolve/DeclarationResolver.java | 30 +-- .../jetbrains/jet/lang/resolve/Importer.java | 8 +- .../jet/lang/resolve/ImportsResolver.java | 31 +-- .../jet/lang/resolve/ModifiersChecker.java | 2 +- .../MutablePackageFragmentProvider.java | 59 ++++++ .../jet/lang/resolve/NamespaceFactory.java | 3 +- .../lang/resolve/NamespaceFactoryImpl.java | 195 +++++------------- .../jet/lang/resolve/OverloadResolver.java | 30 +-- .../resolve/QualifiedExpressionResolver.java | 24 +-- .../lang/resolve/ScriptHeaderResolver.java | 3 +- .../lang/resolve/TopDownAnalysisContext.java | 10 +- .../jet/lang/resolve/TopDownAnalyzer.java | 36 ++-- .../lang/resolve/TypeHierarchyResolver.java | 34 ++- .../resolve/calls/CallExpressionResolver.java | 4 +- .../extension/InlineAnalyzerExtension.java | 2 +- .../lang/resolve/lazy/KotlinCodeAnalyzer.java | 9 +- .../lang/resolve/lazy/LazyImportScope.java | 18 +- .../jet/lang/resolve/lazy/ResolveSession.java | 137 ++++++------ .../resolve/lazy/ResolveSessionUtils.java | 6 +- .../jet/lang/resolve/lazy/ScopeProvider.java | 20 +- .../descriptors/LazyClassMemberScope.java | 3 +- .../descriptors/LazyPackageDescriptor.java | 67 +++--- .../descriptors/LazyPackageMemberScope.java | 35 +--- .../resolve/scopes/JetScopeSelectorUtil.java | 8 +- .../resolve/scopes/WriteThroughScope.java | 41 ++-- compiler/testData/builtin-classes.txt | 2 +- .../recursiveProcessor/declarations.txt | 4 +- .../tests/org/jetbrains/jet/JetTestUtils.java | 26 ++- .../AbstractDescriptorSerializationTest.java | 41 ++-- .../BuiltinsDeserializationTest.java | 30 +-- .../serialization/ClassSerializationUtil.java | 6 +- .../AbstractEvaluateExpressionTest.kt | 4 +- .../AbstractLoadCompiledKotlinTest.java | 52 ++--- .../jvm/compiler/AbstractLoadJavaTest.java | 50 +++-- ...ompileKotlinAgainstCustomBinariesTest.java | 25 +-- .../jvm/compiler/ExpectedLoadErrorsUtil.java | 13 +- .../jet/jvm/compiler/LoadDescriptorUtil.java | 30 +-- ...ractLazyResolveDescriptorRendererTest.java | 8 +- .../AbstractLazyResolveDiagnosticsTest.java | 5 +- ...ractLazyResolveNamespaceComparingTest.java | 5 +- .../resolve/lazy/AbstractLazyResolveTest.java | 5 +- .../lazy/LazyResolveBuiltinClassesTest.java | 4 +- .../lazy/LazyResolveStdlibLoadingTest.java | 5 +- .../resolve/lazy/LazyResolveTestUtil.java | 2 +- .../jet/renderer/DescriptorRendererTest.java | 9 + .../jet/resolve/ExpectedResolveData.java | 4 +- ...stractAnnotationDescriptorResolveTest.java | 35 ++-- .../AbstractAnnotationParameterTest.kt | 4 +- .../jet/test/util/DescriptorValidator.java | 15 +- .../util/RecursiveDescriptorComparator.java | 16 +- .../util/RecursiveDescriptorProcessor.java | 2 +- .../RecursiveDescriptorProcessorTest.java | 8 +- .../jet/types/BoundsSubstitutorTest.java | 2 +- .../jet/types/JetTypeCheckerTest.java | 16 +- .../jet/types/TypeSubstitutorTest.java | 2 +- .../resolve/java/JavaBridgeConfiguration.java | 12 -- .../resolve/java/JavaDescriptorResolver.java | 19 +- .../lang/resolve/java/JavaVisibilities.java | 51 +---- .../descriptor/JavaNamespaceDescriptor.java | 53 ----- .../JavaPackageFragmentDescriptor.java | 87 ++++++++ .../java/resolver/JavaClassResolver.java | 12 +- .../java/resolver/JavaFunctionResolver.java | 69 +++++-- .../java/resolver/JavaMemberResolver.java | 11 - ....java => JavaPackageFragmentProvider.java} | 171 +++++++-------- .../java/resolver/JavaResolverCache.java | 9 +- .../scope/JavaClassStaticMembersScope.java | 45 ++-- .../resolve/java/scope/JavaPackageScope.java | 48 ++--- .../AnnotationDescriptorDeserializer.java | 12 +- .../DeserializedDescriptorResolver.java | 19 +- .../kotlin/DeserializedResolverUtils.java | 7 +- .../lang/descriptors/ModuleDescriptor.java | 5 +- .../descriptors/ModuleDescriptorImpl.java | 47 ++--- .../descriptors/PackageFragmentProvider.java | 34 +++ .../descriptors/PackageViewDescriptor.java | 3 + .../jet/lang/descriptors/Visibilities.java | 12 +- .../impl/AbstractNamespaceDescriptorImpl.java | 5 - .../CompositePackageFragmentProvider.java | 57 +++++ .../MutablePackageFragmentDescriptor.java | 96 +++++++++ .../impl/NamespaceDescriptorImpl.java | 1 + .../impl/NamespaceDescriptorParent.java | 6 +- .../impl/PackageViewDescriptorImpl.java | 155 ++++++++++++++ .../jet/lang/resolve/DescriptorUtils.java | 22 +- .../jet/lang/resolve/name/FqName.java | 5 + .../resolve/scopes/AbstractScopeAdapter.java | 4 +- .../jet/lang/resolve/scopes/ChainedScope.java | 8 +- .../lang/resolve/scopes/FilteringScope.java | 5 +- .../jet/lang/resolve/scopes/JetScope.java | 2 +- .../jet/lang/resolve/scopes/JetScopeImpl.java | 4 +- .../resolve/scopes/SubstitutingScope.java | 4 +- .../lang/resolve/scopes/WritableScope.java | 5 +- .../resolve/scopes/WritableScopeImpl.java | 48 +++-- .../scopes/WritableScopeWithImports.java | 8 +- .../jetbrains/jet/lang/types/ErrorUtils.java | 6 +- .../types/lang/BuiltInsSerializationUtil.java | 19 +- ...Impl.java => BuiltinsPackageFragment.java} | 37 +++- .../jet/lang/types/lang/KotlinBuiltIns.java | 49 +++-- .../jet/renderer/DescriptorRendererImpl.java | 10 +- .../builtins/BuiltInsSerializer.java | 23 +-- .../injectors/GenerateInjectors.java | 9 +- .../jet/plugin/caches/JetShortNamesCache.java | 6 +- .../resolve/JvmDeclarationsCacheProvider.java | 9 +- .../plugin/findUsages/JetUsageTypeProvider.kt | 4 +- .../project/CancelableResolveSession.java | 19 +- .../plugin/project/ResolveElementCache.java | 27 +-- .../quickfix/CreateFunctionFromUsageFix.java | 11 +- .../references/BuiltInsReferenceResolver.java | 2 +- .../BuiltInsReferenceResolverTest.java | 2 +- .../di/InjectorForTopDownAnalyzerForJs.java | 8 +- .../NamespaceDeclarationTranslator.java | 25 +-- .../translate/utils/JsDescriptorUtils.java | 2 +- 141 files changed, 1728 insertions(+), 1465 deletions(-) rename compiler/backend/src/org/jetbrains/jet/codegen/context/{NamespaceContext.java => PackageContext.java} (78%) rename compiler/backend/src/org/jetbrains/jet/codegen/context/{NamespaceFacadeContext.java => PackageFacadeContext.java} (82%) create mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/resolve/MutablePackageFragmentProvider.java delete mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/descriptor/JavaNamespaceDescriptor.java create mode 100644 core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/descriptor/JavaPackageFragmentDescriptor.java rename core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/{JavaNamespaceResolver.java => JavaPackageFragmentProvider.java} (53%) create mode 100644 core/descriptors/src/org/jetbrains/jet/lang/descriptors/PackageFragmentProvider.java create mode 100644 core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/CompositePackageFragmentProvider.java create mode 100644 core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/MutablePackageFragmentDescriptor.java create mode 100644 core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/PackageViewDescriptorImpl.java rename core/descriptors/src/org/jetbrains/jet/lang/types/lang/{BuiltinsNamespaceDescriptorImpl.java => BuiltinsPackageFragment.java} (81%) diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java b/compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java index 3dd88139b2e..9f4ad62fbbf 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java @@ -269,7 +269,7 @@ public class AsmUtil { return ACC_PROTECTED; } } - if (containingDeclaration instanceof NamespaceDescriptor) { + if (containingDeclaration instanceof PackageFragmentDescriptor) { return ACC_PUBLIC; } return null; diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java b/compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java index ef0680eda59..1161b899fb1 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/CodegenUtil.java @@ -25,7 +25,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.codegen.binding.CalculatedClosure; import org.jetbrains.jet.codegen.context.CodegenContext; -import org.jetbrains.jet.codegen.context.NamespaceContext; +import org.jetbrains.jet.codegen.context.PackageContext; import org.jetbrains.jet.codegen.signature.BothSignatureWriter; import org.jetbrains.jet.codegen.signature.JvmMethodParameterKind; import org.jetbrains.jet.codegen.signature.JvmMethodSignature; @@ -194,7 +194,7 @@ public class CodegenUtil { return !isFakeOverride && !isDelegate && (((context.hasThisDescriptor() && containingDeclaration == context.getThisDescriptor()) || - (context.getParentContext() instanceof NamespaceContext && context.getParentContext().getContextDescriptor() == containingDeclaration)) + (context.getParentContext() instanceof PackageContext && context.getParentContext().getContextDescriptor() == containingDeclaration)) && context.getContextKind() != OwnerKind.TRAIT_IMPL); } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java index eed1162ed90..c77155f1817 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ExpressionCodegen.java @@ -1782,7 +1782,7 @@ public class ExpressionCodegen extends JetVisitor implem DeclarationDescriptor containingDeclaration = propertyDescriptor.getContainingDeclaration(); boolean isBackingFieldInAnotherClass = AsmUtil.isPropertyWithBackingFieldInOuterClass(propertyDescriptor); - boolean isStatic = containingDeclaration instanceof NamespaceDescriptor; + boolean isStatic = containingDeclaration instanceof PackageFragmentDescriptor; boolean isSuper = superExpression != null; boolean isInsideClass = isCallInsideSameClassAsDeclared(propertyDescriptor, context); boolean isInsideModule = isCallInsideSameModuleAsDeclared(propertyDescriptor, context); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java index bdb9149edc0..c16677d4d3e 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java @@ -32,7 +32,7 @@ import org.jetbrains.asm4.util.TraceMethodVisitor; import org.jetbrains.jet.codegen.binding.CodegenBinding; import org.jetbrains.jet.codegen.context.CodegenContext; import org.jetbrains.jet.codegen.context.MethodContext; -import org.jetbrains.jet.codegen.context.NamespaceFacadeContext; +import org.jetbrains.jet.codegen.context.PackageFacadeContext; import org.jetbrains.jet.codegen.signature.JvmMethodParameterKind; import org.jetbrains.jet.codegen.signature.JvmMethodParameterSignature; import org.jetbrains.jet.codegen.signature.JvmMethodSignature; @@ -113,8 +113,8 @@ public class FunctionCodegen extends ParentCodegenAwareImpl { jvmSignature.getGenericsSignature(), null); - if (owner instanceof NamespaceFacadeContext) { - Type ownerType = ((NamespaceFacadeContext) owner).getDelegateToClassType(); + if (owner instanceof PackageFacadeContext) { + Type ownerType = ((PackageFacadeContext) owner).getDelegateToClassType(); v.getSerializationBindings().put(IMPL_CLASS_NAME_FOR_CALLABLE, functionDescriptor, shortNameByAsmType(ownerType)); } else { @@ -274,8 +274,8 @@ public class FunctionCodegen extends ParentCodegenAwareImpl { Label methodBegin = new Label(); mv.visitLabel(methodBegin); - if (context.getParentContext() instanceof NamespaceFacadeContext) { - generateStaticDelegateMethodBody(mv, signature.getAsmMethod(), (NamespaceFacadeContext) context.getParentContext()); + if (context.getParentContext() instanceof PackageFacadeContext) { + generateStaticDelegateMethodBody(mv, signature.getAsmMethod(), (PackageFacadeContext) context.getParentContext()); } else { FrameMap frameMap = strategy.getFrameMap(typeMapper, context); @@ -411,7 +411,7 @@ public class FunctionCodegen extends ParentCodegenAwareImpl { private static void generateStaticDelegateMethodBody( @NotNull MethodVisitor mv, @NotNull Method asmMethod, - @NotNull NamespaceFacadeContext context + @NotNull PackageFacadeContext context ) { InstructionAdapter iv = new InstructionAdapter(mv); Type[] argTypes = asmMethod.getArgumentTypes(); @@ -585,7 +585,7 @@ public class FunctionCodegen extends ParentCodegenAwareImpl { int flags = ACC_PUBLIC | ACC_SYNTHETIC; // TODO. Type ownerType; - if (contextClass instanceof NamespaceDescriptor) { + if (contextClass instanceof PackageFragmentDescriptor) { ownerType = state.getTypeMapper().getOwner(functionDescriptor, kind, true); } else if (contextClass instanceof ClassDescriptor) { diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/FunctionTypesUtil.java b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionTypesUtil.java index babf1940fc4..c0720ed5511 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/FunctionTypesUtil.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionTypesUtil.java @@ -143,7 +143,7 @@ public class FunctionTypesUtil { JetScope builtInsScope = KotlinBuiltIns.getInstance().getBuiltInsScope(); MutableClassDescriptor functionImpl = new MutableClassDescriptor( - builtInsScope.getContainingDeclaration(), + KotlinBuiltIns.getInstance().getBuiltInsPackageFragment(), builtInsScope, ClassKind.CLASS, false, diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java index 8674e11d75e..b36e8e2efff 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java @@ -234,7 +234,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { boolean isObjectLiteral = DescriptorUtils.isAnonymousObject(descriptor); boolean isLocalOrAnonymousClass = isObjectLiteral || - !(parentDescriptor instanceof NamespaceDescriptor || parentDescriptor instanceof ClassDescriptor); + !(parentDescriptor instanceof PackageFragmentDescriptor || parentDescriptor instanceof ClassDescriptor); // Do not emit enclosing method in "light-classes mode" since currently we genenerate local light classes as if they're top level if (isLocalOrAnonymousClass && getState().getClassBuilderMode() != ClassBuilderMode.LIGHT_CLASSES) { String outerClassName = getOuterClassName(descriptor, typeMapper); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java index 5a86794c013..34e3400fafc 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java @@ -16,11 +16,13 @@ package org.jetbrains.jet.codegen; +import com.google.common.collect.Sets; import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.progress.ProcessCanceledException; import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.vfs.VirtualFile; import com.intellij.psi.PsiFile; +import com.intellij.util.ArrayUtil; import com.intellij.util.PathUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -33,7 +35,7 @@ import org.jetbrains.jet.descriptors.serialization.BitEncoding; import org.jetbrains.jet.descriptors.serialization.DescriptorSerializer; import org.jetbrains.jet.descriptors.serialization.PackageData; import org.jetbrains.jet.descriptors.serialization.ProtoBuf; -import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; @@ -43,9 +45,7 @@ import org.jetbrains.jet.lang.resolve.java.JvmClassName; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; -import java.util.ArrayList; -import java.util.Collection; -import java.util.List; +import java.util.*; import static org.jetbrains.asm4.Opcodes.*; import static org.jetbrains.jet.codegen.AsmUtil.asmDescByFqNameWithoutInnerClasses; @@ -54,7 +54,6 @@ import static org.jetbrains.jet.descriptors.serialization.NameSerializationUtil. import static org.jetbrains.jet.lang.resolve.java.PackageClassUtils.getPackageClassFqName; public class NamespaceCodegen extends MemberCodegen { - @NotNull private final ClassBuilderOnDemand v; @NotNull @@ -62,7 +61,7 @@ public class NamespaceCodegen extends MemberCodegen { @NotNull private final Collection files; - private final NamespaceDescriptor descriptor; + private final Set packageFragments; public NamespaceCodegen( @NotNull ClassBuilderOnDemand v, @@ -77,8 +76,10 @@ public class NamespaceCodegen extends MemberCodegen { name = fqName; this.files = namespaceFiles; - descriptor = state.getBindingContext().get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, name); - assert descriptor != null : "No namespace found for FQ name " + name; + packageFragments = Sets.newHashSet(); + for (JetFile file : namespaceFiles) { + packageFragments.add(getPackageFragment(file)); + } final PsiFile sourceFile = namespaceFiles.size() == 1 ? namespaceFiles.iterator().next().getContainingFile() : null; @@ -89,9 +90,8 @@ public class NamespaceCodegen extends MemberCodegen { ACC_PUBLIC | ACC_FINAL, JvmClassName.byFqNameWithoutInnerClasses(getPackageClassFqName(fqName)).getInternalName(), null, - //"jet/lang/Namespace", "java/lang/Object", - new String[0] + ArrayUtil.EMPTY_STRING_ARRAY ); //We don't generate any source information for namespace with multiple files if (sourceFile != null) { @@ -147,7 +147,7 @@ public class NamespaceCodegen extends MemberCodegen { } DescriptorSerializer serializer = new DescriptorSerializer(new JavaSerializerExtension(bindings)); - ProtoBuf.Package packageProto = serializer.packageProto(descriptor).build(); + ProtoBuf.Package packageProto = serializer.packageProto(packageFragments).build(); if (packageProto.getMemberCount() == 0) return; @@ -167,7 +167,7 @@ public class NamespaceCodegen extends MemberCodegen { @Nullable private ClassBuilder generate(@NotNull JetFile file) { boolean generateSrcClass = false; - FieldOwnerContext packageFragmentContext = CodegenContext.STATIC.intoNamespace(descriptor); + FieldOwnerContext packagePartContext = CodegenContext.STATIC.intoPackagePart(getPackageFragment(file)); for (JetDeclaration declaration : file.getDeclarations()) { if (declaration instanceof JetProperty || declaration instanceof JetNamedFunction) { @@ -179,18 +179,18 @@ public class NamespaceCodegen extends MemberCodegen { } } else if (declaration instanceof JetScript) { - ScriptCodegen.createScriptCodegen((JetScript) declaration, state, packageFragmentContext).generate(); + ScriptCodegen.createScriptCodegen((JetScript) declaration, state, packagePartContext).generate(); } } if (!generateSrcClass) return null; - Type packageFragmentType = getNamespacePartType(getPackageClassFqName(name), file.getVirtualFile()); - ClassBuilder builder = state.getFactory().forPackageFragment(packageFragmentType, file); + Type packagePartType = getNamespacePartType(getPackageClassFqName(name), file.getVirtualFile()); + ClassBuilder builder = state.getFactory().forPackageFragment(packagePartType, file); - new NamespacePartCodegen(builder, file, packageFragmentType, packageFragmentContext, state).generate(); + new NamespacePartCodegen(builder, file, packagePartType, packagePartContext, state).generate(); - FieldOwnerContext namespaceFacade = CodegenContext.STATIC.intoNamespaceFacade(packageFragmentType, descriptor); + FieldOwnerContext namespaceFacade = CodegenContext.STATIC.intoPackageFacade(packagePartType, getPackageFragment(file)); for (JetDeclaration declaration : file.getDeclarations()) { if (declaration instanceof JetNamedFunction || declaration instanceof JetProperty) { @@ -201,8 +201,15 @@ public class NamespaceCodegen extends MemberCodegen { return builder; } + @NotNull + private PackageFragmentDescriptor getPackageFragment(@NotNull JetFile file) { + PackageFragmentDescriptor packageFragment = bindingContext.get(BindingContext.FILE_TO_PACKAGE_FRAGMENT, file); + assert packageFragment != null : "package fragment is null for " + file; + return packageFragment; + } + public void generateClassOrObject(@NotNull JetClassOrObject classOrObject) { - CodegenContext context = CodegenContext.STATIC.intoNamespace(descriptor); + CodegenContext context = CodegenContext.STATIC.intoPackagePart(getPackageFragment((JetFile) classOrObject.getContainingFile())); genClassOrObject(context, classOrObject); } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/NamespacePartCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/NamespacePartCodegen.java index b4b66492822..bb1661ce63f 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/NamespacePartCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/NamespacePartCodegen.java @@ -17,6 +17,7 @@ package org.jetbrains.jet.codegen; import com.google.common.collect.Lists; +import com.intellij.util.ArrayUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.asm4.AnnotationVisitor; import org.jetbrains.asm4.MethodVisitor; @@ -42,7 +43,7 @@ public class NamespacePartCodegen extends MemberCodegen { private final ClassBuilder v; - private final NamespaceDescriptor descriptor; + private final PackageFragmentDescriptor descriptor; private final JetFile jetFile; @@ -62,7 +63,7 @@ public class NamespacePartCodegen extends MemberCodegen { this.jetFile = jetFile; this.namespacePartName = namespacePartName; this.context = context; - descriptor = state.getBindingContext().get(BindingContext.FILE_TO_NAMESPACE, jetFile); + descriptor = state.getBindingContext().get(BindingContext.FILE_TO_PACKAGE_FRAGMENT, jetFile); assert descriptor != null : "No namespace found for jetFile " + jetFile + " declared package: " + jetFile.getPackageName(); } @@ -71,9 +72,8 @@ public class NamespacePartCodegen extends MemberCodegen { ACC_PUBLIC | ACC_FINAL, namespacePartName.getInternalName(), null, - //"jet/lang/Namespace", "java/lang/Object", - new String[0] + ArrayUtil.EMPTY_STRING_ARRAY ); v.visitSource(jetFile.getName(), null); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java index 7c5209b42ad..addc6bcf5bf 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/PropertyCodegen.java @@ -28,7 +28,7 @@ import org.jetbrains.asm4.commons.InstructionAdapter; import org.jetbrains.asm4.commons.Method; import org.jetbrains.jet.codegen.context.CodegenContext; import org.jetbrains.jet.codegen.context.FieldOwnerContext; -import org.jetbrains.jet.codegen.context.NamespaceFacadeContext; +import org.jetbrains.jet.codegen.context.PackageFacadeContext; import org.jetbrains.jet.codegen.signature.JvmMethodSignature; import org.jetbrains.jet.codegen.state.GenerationState; import org.jetbrains.jet.codegen.state.GenerationStateAware; @@ -92,8 +92,8 @@ public class PropertyCodegen extends GenerationStateAware { : "Generating property with a wrong kind (" + kind + "): " + propertyDescriptor; - if (context instanceof NamespaceFacadeContext) { - Type ownerType = ((NamespaceFacadeContext) context).getDelegateToClassType(); + if (context instanceof PackageFacadeContext) { + Type ownerType = ((PackageFacadeContext) context).getDelegateToClassType(); v.getSerializationBindings().put(IMPL_CLASS_NAME_FOR_CALLABLE, propertyDescriptor, shortNameByAsmType(ownerType)); } else if (!generateBackingField(p, propertyDescriptor)) { diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenAnnotatingVisitor.java b/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenAnnotatingVisitor.java index c21f36b35ff..1daac95ce1f 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenAnnotatingVisitor.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenAnnotatingVisitor.java @@ -379,8 +379,8 @@ class CodegenAnnotatingVisitor extends JetVisitorVoid { if (containingDeclaration instanceof ClassDescriptor) { return peek + '$' + name; } - else if (containingDeclaration instanceof NamespaceDescriptor) { - FqName qualifiedName = ((NamespaceDescriptor) containingDeclaration).getFqName(); + else if (containingDeclaration instanceof PackageFragmentDescriptor) { + FqName qualifiedName = ((PackageFragmentDescriptor) containingDeclaration).getFqName(); String packageClassShortName = PackageClassUtils.getPackageClassName(qualifiedName); String packageClassName = peek.isEmpty() ? packageClassShortName : peek + "/" + packageClassShortName; return packageClassName + '$' + name; diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenBinding.java b/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenBinding.java index e00f365202a..51c9a90c3fb 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenBinding.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/binding/CodegenBinding.java @@ -240,8 +240,7 @@ public class CodegenBinding { answer.addAll(files); for (FqName name : names) { - NamespaceDescriptor namespaceDescriptor = bindingContext.get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, name); - Collection jetFiles = bindingContext.get(NAMESPACE_TO_FILES, namespaceDescriptor); + Collection jetFiles = bindingContext.get(PACKAGE_TO_FILES, name); if (jetFiles != null) { answer.addAll(jetFiles); } @@ -289,6 +288,7 @@ public class CodegenBinding { return false; } + // TODO 2 accept ClassDescriptor and simplify @NotNull public static Type getAsmType(@NotNull BindingTrace bindingTrace, @NotNull DeclarationDescriptor descriptor) { descriptor = descriptor.getOriginal(); @@ -304,14 +304,19 @@ public class CodegenBinding { return asmType; } + // TODO 2 accept ClassDescriptor and simplify @NotNull private static String getAsmTypeImpl(@NotNull BindingTrace bindingTrace, @NotNull DeclarationDescriptor descriptor) { + if (descriptor instanceof PackageFragmentDescriptor) { + throw new IllegalStateException("package is unexpected: " + descriptor); + } + if (descriptor instanceof FunctionDescriptor) { throw new IllegalStateException("requested fq name for function: " + descriptor); } if (descriptor instanceof ModuleDescriptor) { - throw new IllegalStateException("missed something"); + throw new IllegalStateException("module is unexpected: " + descriptor); } DeclarationDescriptor container = descriptor.getContainingDeclaration(); @@ -319,13 +324,21 @@ public class CodegenBinding { throw new IllegalStateException("descriptor has no container: " + descriptor); } - if (container.getContainingDeclaration() instanceof ModuleDescriptor || container instanceof ScriptDescriptor) { + if (container instanceof ScriptDescriptor) { return descriptor.getName().getIdentifier(); } - String containerInternalName = getAsmType(bindingTrace, container).getInternalName(); - if (descriptor instanceof ClassDescriptor && container instanceof ClassDescriptor) { + if (container instanceof PackageFragmentDescriptor) { + String shortName = descriptor.getName().getIdentifier(); + FqName fqName = ((PackageFragmentDescriptor) container).getFqName(); + return fqName.isRoot() ? shortName : fqName.asString().replace('.', '/') + '/' + shortName; + } + + if (descriptor instanceof ClassDescriptor) { + assert container instanceof ClassDescriptor : "Unexpected container: " + container + " for " + descriptor; + + String containerInternalName = getAsmType(bindingTrace, container).getInternalName(); ClassDescriptor klass = (ClassDescriptor) descriptor; if (klass.getKind() == ClassKind.OBJECT || klass.getKind() == ClassKind.CLASS_OBJECT) { if (isEnumClass(container)) { @@ -338,9 +351,10 @@ public class CodegenBinding { return containerInternalName + JvmAbi.CLASS_OBJECT_SUFFIX; } } + return containerInternalName + "$" + descriptor.getName().getIdentifier(); } - return containerInternalName + (container instanceof NamespaceDescriptor ? "/" : "$") + descriptor.getName().getIdentifier(); + throw new IllegalStateException("neither top-level nor nested class: " + descriptor); } public static boolean isVarCapturedInClosure(BindingContext bindingContext, DeclarationDescriptor descriptor) { diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/context/CodegenContext.java b/compiler/backend/src/org/jetbrains/jet/codegen/context/CodegenContext.java index 9841af9ba65..89861e3860b 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/context/CodegenContext.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/context/CodegenContext.java @@ -106,7 +106,7 @@ public abstract class CodegenContext { while (true) { assert c != null; DeclarationDescriptor contextDescriptor = c.getContextDescriptor(); - if (!(contextDescriptor instanceof ClassDescriptor) && !(contextDescriptor instanceof NamespaceDescriptor)) { + if (!(contextDescriptor instanceof ClassDescriptor) && !(contextDescriptor instanceof PackageFragmentDescriptor)) { c = c.getParentContext(); } else { @@ -157,13 +157,13 @@ public abstract class CodegenContext { } @NotNull - public FieldOwnerContext intoNamespace(@NotNull NamespaceDescriptor descriptor) { - return new NamespaceContext(descriptor, this); + public FieldOwnerContext intoPackagePart(@NotNull PackageFragmentDescriptor descriptor) { + return new PackageContext(descriptor, this); } @NotNull - public FieldOwnerContext intoNamespaceFacade(@NotNull Type delegateTo, @NotNull NamespaceDescriptor descriptor) { - return new NamespaceFacadeContext(descriptor, this, delegateTo); + public FieldOwnerContext intoPackageFacade(@NotNull Type delegateTo, @NotNull PackageFragmentDescriptor descriptor) { + return new PackageFacadeContext(descriptor, this, delegateTo); } @NotNull diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/context/NamespaceContext.java b/compiler/backend/src/org/jetbrains/jet/codegen/context/PackageContext.java similarity index 78% rename from compiler/backend/src/org/jetbrains/jet/codegen/context/NamespaceContext.java rename to compiler/backend/src/org/jetbrains/jet/codegen/context/PackageContext.java index 1b957189f50..32c811e80ad 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/context/NamespaceContext.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/context/PackageContext.java @@ -18,13 +18,12 @@ package org.jetbrains.jet.codegen.context; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.asm4.Type; import org.jetbrains.jet.codegen.OwnerKind; -import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor; -public class NamespaceContext extends FieldOwnerContext { - - public NamespaceContext(@NotNull NamespaceDescriptor contextDescriptor, @Nullable CodegenContext parent) { +public class PackageContext extends FieldOwnerContext { + + public PackageContext(@NotNull PackageFragmentDescriptor contextDescriptor, @Nullable CodegenContext parent) { super(contextDescriptor, OwnerKind.NAMESPACE, parent, null, null, null); } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/context/NamespaceFacadeContext.java b/compiler/backend/src/org/jetbrains/jet/codegen/context/PackageFacadeContext.java similarity index 82% rename from compiler/backend/src/org/jetbrains/jet/codegen/context/NamespaceFacadeContext.java rename to compiler/backend/src/org/jetbrains/jet/codegen/context/PackageFacadeContext.java index e3bcce3a1ab..5bcb5d9e308 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/context/NamespaceFacadeContext.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/context/PackageFacadeContext.java @@ -19,14 +19,14 @@ package org.jetbrains.jet.codegen.context; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.asm4.Type; -import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor; -public class NamespaceFacadeContext extends NamespaceContext { +public class PackageFacadeContext extends PackageContext { private final Type delegateTo; - public NamespaceFacadeContext( - @NotNull NamespaceDescriptor contextDescriptor, + public PackageFacadeContext( + @NotNull PackageFragmentDescriptor contextDescriptor, @Nullable CodegenContext parent, @NotNull Type delegateTo ) { diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/state/GenerationState.java b/compiler/backend/src/org/jetbrains/jet/codegen/state/GenerationState.java index 4ba4170f64e..9ff8a236a56 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/state/GenerationState.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/state/GenerationState.java @@ -75,7 +75,13 @@ public class GenerationState { @Nullable private List earlierScriptsForReplInterpreter; - public GenerationState(Project project, ClassBuilderFactory builderFactory, BindingContext bindingContext, List files, boolean inlineEnabled) { + public GenerationState( + @NotNull Project project, + @NotNull ClassBuilderFactory builderFactory, + @NotNull BindingContext bindingContext, + @NotNull List files, + boolean inlineEnabled + ) { this(project, builderFactory, Progress.DEAF, bindingContext, files, true, false, true, inlineEnabled); } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java b/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java index af0797597b6..62f2592b3e0 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/state/JetTypeMapper.java @@ -16,7 +16,6 @@ package org.jetbrains.jet.codegen.state; -import com.google.common.collect.Lists; import com.intellij.psi.PsiElement; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; @@ -30,6 +29,7 @@ import org.jetbrains.jet.codegen.signature.BothSignatureWriter; import org.jetbrains.jet.codegen.signature.JvmMethodParameterKind; import org.jetbrains.jet.codegen.signature.JvmMethodParameterSignature; import org.jetbrains.jet.codegen.signature.JvmMethodSignature; +import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedPackageMemberScope; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; @@ -37,10 +37,18 @@ import org.jetbrains.jet.lang.resolve.BindingContextUtils; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.calls.util.ExpressionAsFunctionDescriptor; -import org.jetbrains.jet.lang.resolve.java.*; +import org.jetbrains.jet.lang.resolve.java.AsmTypeConstants; +import org.jetbrains.jet.lang.resolve.java.JvmAbi; +import org.jetbrains.jet.lang.resolve.java.PackageClassUtils; +import org.jetbrains.jet.lang.resolve.java.descriptor.JavaPackageFragmentDescriptor; import org.jetbrains.jet.lang.resolve.java.mapping.KotlinToJavaTypesMap; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProvider; +import org.jetbrains.jet.lang.resolve.java.scope.JavaClassStaticMembersScope; +import org.jetbrains.jet.lang.resolve.java.scope.JavaPackageScope; +import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.resolve.name.Name; +import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.types.*; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; @@ -88,8 +96,8 @@ public class JetTypeMapper extends BindingTraceAware { @NotNull public Type getOwner(@NotNull DeclarationDescriptor descriptor, @NotNull OwnerKind kind, boolean isInsideModule) { DeclarationDescriptor containingDeclaration = descriptor.getContainingDeclaration(); - if (containingDeclaration instanceof NamespaceDescriptor) { - return asmTypeForNamespace((NamespaceDescriptor) containingDeclaration, descriptor, isInsideModule); + if (containingDeclaration instanceof PackageFragmentDescriptor) { + return asmTypeForPackage((PackageFragmentDescriptor) containingDeclaration, descriptor, isInsideModule); } else if (containingDeclaration instanceof ClassDescriptor) { ClassDescriptor classDescriptor = (ClassDescriptor) containingDeclaration; @@ -104,84 +112,57 @@ public class JetTypeMapper extends BindingTraceAware { } @NotNull - private JavaNamespaceKind getNsKind(@NotNull NamespaceDescriptor ns) { - JavaNamespaceKind javaNamespaceKind = bindingContext.get(JavaBindingContext.JAVA_NAMESPACE_KIND, ns); - Boolean src = bindingContext.get(BindingContext.NAMESPACE_IS_SRC, ns); - - if (javaNamespaceKind == null && src == null) { - throw new IllegalStateException("unknown namespace origin: " + ns); - } - - if (javaNamespaceKind != null) { - if (javaNamespaceKind == JavaNamespaceKind.CLASS_STATICS && src != null) { - throw new IllegalStateException( - "conflicting namespace " + ns + ": it is both java statics and from src"); - } - return javaNamespaceKind; - } - else { - return JavaNamespaceKind.PROPER; - } - } - - @NotNull - private Type asmTypeForNamespace( - @NotNull NamespaceDescriptor namespace, + private Type asmTypeForPackage( + @NotNull PackageFragmentDescriptor packageFragment, @NotNull DeclarationDescriptor descriptor, boolean insideModule ) { - StringBuilder r = new StringBuilder(); - - List path = getPathWithoutRootNsAndModule(namespace); - - for (DeclarationDescriptor pathElement : path) { - NamespaceDescriptor ns = (NamespaceDescriptor) pathElement; - if (r.length() > 0) { - JavaNamespaceKind nsKind = getNsKind((NamespaceDescriptor) ns.getContainingDeclaration()); - if (nsKind == JavaNamespaceKind.PROPER) { - r.append("/"); - } - else if (nsKind == JavaNamespaceKind.CLASS_STATICS) { - r.append("$"); - } - } - r.append(ns.getName()); - } - - if (getNsKind(namespace) == JavaNamespaceKind.PROPER) { - if (r.length() > 0) { - r.append("/"); - } - - JetFile file = BindingContextUtils.getContainingFile(bindingContext, descriptor); - if (insideModule && file != null) { - String internalName = NamespaceCodegen.getNamespacePartInternalName(file); - r.append(internalName.substring(r.length())); - } - else { - r.append(PackageClassUtils.getPackageClassName(namespace.getFqName())); - } - } - - if (r.length() == 0) { - throw new IllegalStateException("internal error: failed to generate classname for " + namespace); - } - - return Type.getObjectType(r.toString()); + return Type.getObjectType(internalNameForPackage(packageFragment, descriptor, insideModule)); } @NotNull - public static List getPathWithoutRootNsAndModule(@NotNull NamespaceDescriptor descriptor) { - List path = new ArrayList(); - DeclarationDescriptor current = descriptor; - while (true) { - if (current instanceof NamespaceDescriptor && DescriptorUtils.isRootNamespace((NamespaceDescriptor) current)) { - return Lists.reverse(path); + private String internalNameForPackage( + @NotNull PackageFragmentDescriptor packageFragment, + @NotNull DeclarationDescriptor descriptor, + boolean insideModule + ) { + if (!(packageFragment instanceof JavaPackageFragmentDescriptor) || packageFragment.getMemberScope() instanceof DeserializedPackageMemberScope) { + JetFile file = BindingContextUtils.getContainingFile(bindingContext, descriptor); + if (insideModule && file != null) { + return NamespaceCodegen.getNamespacePartInternalName(file); + } + else { + return PackageClassUtils.getPackageClassFqName(packageFragment.getFqName()).asString().replace('.', '/'); } - path.add(current); - assert current != null : "Namespace must have a parent: " + descriptor; - current = current.getContainingDeclaration(); } + + if (!(packageFragment.getMemberScope() instanceof JavaClassStaticMembersScope)) { + throw new IllegalStateException("Unexpected scope: " + packageFragment.getMemberScope().getClass()); + } + + JavaPackageFragmentProvider javaFragmentProvider = ((JavaPackageFragmentDescriptor) packageFragment).getProvider(); + + StringBuilder r = new StringBuilder(); + for (FqName pathItem : packageFragment.getFqName().parent().path()) { + if (pathItem.isRoot()) { + continue; + } + r.append(pathItem.shortName().asString()); + + JetScope memberScope = javaFragmentProvider.getOrCreatePackage(pathItem).getMemberScope(); + if (memberScope instanceof JavaClassStaticMembersScope) { + r.append("$"); + } + else if (memberScope instanceof JavaPackageScope) { + r.append("/"); + } + else { + throw new IllegalStateException("Unexpected scope: " + memberScope.getClass()); + } + } + + r.append(packageFragment.getName().asString()); + return r.toString(); } @NotNull @@ -473,9 +454,9 @@ public class JetTypeMapper extends BindingTraceAware { descriptor = mapSignature("invoke", functionDescriptor, true, kind); calleeType = owner; } - else if (functionParent instanceof NamespaceDescriptor) { + else if (functionParent instanceof PackageFragmentDescriptor) { assert !superCall; - owner = asmTypeForNamespace((NamespaceDescriptor) functionParent, functionDescriptor, isInsideModule); + owner = asmTypeForPackage((PackageFragmentDescriptor) functionParent, functionDescriptor, isInsideModule); ownerForDefaultImpl = ownerForDefaultParam = owner; invokeOpcode = INVOKESTATIC; thisClass = null; diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CliLightClassGenerationSupport.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CliLightClassGenerationSupport.java index d97e6c7fa54..6a7a72ac5eb 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CliLightClassGenerationSupport.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CliLightClassGenerationSupport.java @@ -133,17 +133,14 @@ public class CliLightClassGenerationSupport extends LightClassGenerationSupport @NotNull @Override public Collection findFilesForPackage(@NotNull FqName fqName, @NotNull final GlobalSearchScope searchScope) { - NamespaceDescriptor namespaceDescriptor = getTrace().get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, fqName); - if (namespaceDescriptor != null) { - Collection files = getTrace().get(BindingContext.NAMESPACE_TO_FILES, namespaceDescriptor); - if (files != null) { - return Collections2.filter(files, new Predicate() { - @Override - public boolean apply(JetFile input) { - return PsiSearchScopeUtil.isInScope(searchScope, input); - } - }); - } + Collection files = getTrace().get(BindingContext.PACKAGE_TO_FILES, fqName); + if (files != null) { + return Collections2.filter(files, new Predicate() { + @Override + public boolean apply(JetFile input) { + return PsiSearchScopeUtil.isInScope(searchScope, input); + } + }); } return Collections.emptyList(); } diff --git a/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java b/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java index cfb421b42f4..1eb4464784d 100644 --- a/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java +++ b/compiler/cli/src/org/jetbrains/jet/cli/jvm/repl/ReplInterpreter.java @@ -45,7 +45,6 @@ import org.jetbrains.jet.config.CompilerConfiguration; import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm; import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl; import org.jetbrains.jet.lang.descriptors.ScriptDescriptor; -import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorImpl; import org.jetbrains.jet.lang.descriptors.impl.NamespaceLikeBuilderDummy; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetPsiUtil; @@ -287,15 +286,12 @@ public class ReplInterpreter { scope.changeLockLevel(WritableScope.LockLevel.BOTH); - NamespaceDescriptorImpl rootNs = injector.getNamespaceFactory().createNamespaceDescriptorPathIfNeeded(FqName.ROOT); - - // map "jet" namespace into KotlinBuiltIns - // @see DefaultModuleConfiguraiton#extendNamespaceScope - injector.getNamespaceFactory().createNamespaceDescriptorPathIfNeeded(KotlinBuiltIns.getInstance().getBuiltInsPackageFqName()); + module.addFragmentProvider(injector.getTopDownAnalyzer().getPackageFragmentProvider()); + module.addFragmentProvider(KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider()); // Import a scope that contains all top-level namespaces that come from dependencies // This makes the namespaces visible at all, does not import themselves - scope.importScope(rootNs.getMemberScope()); + scope.importScope(module.getPackage(FqName.ROOT).getMemberScope()); if (lastLineScope != null) { scope.importScope(lastLineScope); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java index 308ba4a29d8..29e03d0f5fb 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForJavaDescriptorResolver.java @@ -17,6 +17,7 @@ package org.jetbrains.jet.di; import com.intellij.openapi.project.Project; +import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.java.JavaClassFinderImpl; import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedExternalSignatureResolver; @@ -27,12 +28,13 @@ import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedExternalAnnotationRe import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileKotlinClassFinder; import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder; +import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationArgumentResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver; import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver; import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorDeserializer; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProvider; import org.jetbrains.jet.lang.resolve.java.resolver.JavaMemberResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaTypeTransformer; @@ -58,12 +60,13 @@ public class InjectorForJavaDescriptorResolver { private final JavaDescriptorResolver javaDescriptorResolver; private final VirtualFileKotlinClassFinder virtualFileKotlinClassFinder; private final VirtualFileFinder virtualFileFinder; + private final ModuleDescriptorImpl module; private final JavaAnnotationResolver javaAnnotationResolver; private final JavaAnnotationArgumentResolver javaAnnotationArgumentResolver; private final JavaClassResolver javaClassResolver; private final DeserializedDescriptorResolver deserializedDescriptorResolver; private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer; - private final JavaNamespaceResolver javaNamespaceResolver; + private final JavaPackageFragmentProvider javaPackageFragmentProvider; private final JavaMemberResolver javaMemberResolver; private final JavaConstructorResolver javaConstructorResolver; private final JavaTypeTransformer javaTypeTransformer; @@ -88,12 +91,13 @@ public class InjectorForJavaDescriptorResolver { this.javaDescriptorResolver = new JavaDescriptorResolver(); this.virtualFileKotlinClassFinder = new VirtualFileKotlinClassFinder(); this.virtualFileFinder = com.intellij.openapi.components.ServiceManager.getService(project, VirtualFileFinder.class); + this.module = org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM.createJavaModule(""); this.javaAnnotationResolver = new JavaAnnotationResolver(); this.javaAnnotationArgumentResolver = new JavaAnnotationArgumentResolver(); this.javaClassResolver = new JavaClassResolver(); this.deserializedDescriptorResolver = new DeserializedDescriptorResolver(); this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer(); - this.javaNamespaceResolver = new JavaNamespaceResolver(); + this.javaPackageFragmentProvider = new JavaPackageFragmentProvider(); this.javaMemberResolver = new JavaMemberResolver(); this.javaConstructorResolver = new JavaConstructorResolver(); this.javaTypeTransformer = new JavaTypeTransformer(); @@ -116,7 +120,7 @@ public class InjectorForJavaDescriptorResolver { psiBasedMethodSignatureChecker.setExternalSignatureResolver(traceBasedExternalSignatureResolver); this.javaDescriptorResolver.setClassResolver(javaClassResolver); - this.javaDescriptorResolver.setNamespaceResolver(javaNamespaceResolver); + this.javaDescriptorResolver.setPackageFragmentProvider(javaPackageFragmentProvider); virtualFileKotlinClassFinder.setVirtualFileFinder(virtualFileFinder); @@ -135,29 +139,29 @@ public class InjectorForJavaDescriptorResolver { javaClassResolver.setJavaClassFinder(javaClassFinder); javaClassResolver.setKotlinClassFinder(virtualFileKotlinClassFinder); javaClassResolver.setMemberResolver(javaMemberResolver); - javaClassResolver.setNamespaceResolver(javaNamespaceResolver); + javaClassResolver.setPackageFragmentProvider(javaPackageFragmentProvider); javaClassResolver.setSupertypesResolver(javaSupertypeResolver); javaClassResolver.setTypeParameterResolver(javaTypeParameterResolver); deserializedDescriptorResolver.setAnnotationDeserializer(annotationDescriptorDeserializer); deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter); deserializedDescriptorResolver.setJavaClassResolver(javaClassResolver); - deserializedDescriptorResolver.setJavaNamespaceResolver(javaNamespaceResolver); + deserializedDescriptorResolver.setJavaPackageFragmentProvider(javaPackageFragmentProvider); annotationDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter); annotationDescriptorDeserializer.setJavaClassResolver(javaClassResolver); annotationDescriptorDeserializer.setKotlinClassFinder(virtualFileKotlinClassFinder); - javaNamespaceResolver.setCache(traceBasedJavaResolverCache); - javaNamespaceResolver.setDeserializedDescriptorResolver(deserializedDescriptorResolver); - javaNamespaceResolver.setJavaClassFinder(javaClassFinder); - javaNamespaceResolver.setKotlinClassFinder(virtualFileKotlinClassFinder); - javaNamespaceResolver.setMemberResolver(javaMemberResolver); + javaPackageFragmentProvider.setCache(traceBasedJavaResolverCache); + javaPackageFragmentProvider.setDeserializedDescriptorResolver(deserializedDescriptorResolver); + javaPackageFragmentProvider.setJavaClassFinder(javaClassFinder); + javaPackageFragmentProvider.setKotlinClassFinder(virtualFileKotlinClassFinder); + javaPackageFragmentProvider.setMemberResolver(javaMemberResolver); + javaPackageFragmentProvider.setModule(module); javaMemberResolver.setClassResolver(javaClassResolver); javaMemberResolver.setConstructorResolver(javaConstructorResolver); javaMemberResolver.setFunctionResolver(javaFunctionResolver); - javaMemberResolver.setNamespaceResolver(javaNamespaceResolver); javaMemberResolver.setPropertyResolver(javaPropertyResolver); javaConstructorResolver.setCache(traceBasedJavaResolverCache); @@ -206,4 +210,8 @@ public class InjectorForJavaDescriptorResolver { return this.javaDescriptorResolver; } + public ModuleDescriptorImpl getModule() { + return this.module; + } + } 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 0d3b62218a3..8b1f4110ba8 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJvm.java @@ -37,6 +37,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.TraceBasedErrorReporter; import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedMethodSignatureChecker; import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedExternalAnnotationResolver; import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileKotlinClassFinder; +import org.jetbrains.jet.lang.resolve.MutablePackageFragmentProvider; import org.jetbrains.jet.lang.resolve.NamespaceFactoryImpl; import org.jetbrains.jet.lang.resolve.kotlin.VirtualFileFinder; import org.jetbrains.jet.lang.resolve.DeclarationResolver; @@ -63,7 +64,7 @@ import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationArgumentResolv import org.jetbrains.jet.lang.resolve.java.resolver.JavaTypeTransformer; import org.jetbrains.jet.lang.resolve.kotlin.DeserializedDescriptorResolver; import org.jetbrains.jet.lang.resolve.kotlin.AnnotationDescriptorDeserializer; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProvider; import org.jetbrains.jet.lang.resolve.java.resolver.JavaMemberResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaConstructorResolver; import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver; @@ -98,6 +99,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly private final PsiBasedMethodSignatureChecker psiBasedMethodSignatureChecker; private final PsiBasedExternalAnnotationResolver psiBasedExternalAnnotationResolver; private final VirtualFileKotlinClassFinder virtualFileKotlinClassFinder; + private final MutablePackageFragmentProvider mutablePackageFragmentProvider; private final NamespaceFactoryImpl namespaceFactory; private final VirtualFileFinder virtualFileFinder; private final DeclarationResolver declarationResolver; @@ -124,7 +126,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly private final JavaTypeTransformer javaTypeTransformer; private final DeserializedDescriptorResolver deserializedDescriptorResolver; private final AnnotationDescriptorDeserializer annotationDescriptorDeserializer; - private final JavaNamespaceResolver javaNamespaceResolver; + private final JavaPackageFragmentProvider javaPackageFragmentProvider; private final JavaMemberResolver javaMemberResolver; private final JavaConstructorResolver javaConstructorResolver; private final JavaValueParameterResolver javaValueParameterResolver; @@ -160,6 +162,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly this.psiBasedMethodSignatureChecker = new PsiBasedMethodSignatureChecker(); this.psiBasedExternalAnnotationResolver = new PsiBasedExternalAnnotationResolver(); this.virtualFileKotlinClassFinder = new VirtualFileKotlinClassFinder(); + this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(getModuleDescriptor()); this.namespaceFactory = new NamespaceFactoryImpl(); this.virtualFileFinder = com.intellij.openapi.components.ServiceManager.getService(project, VirtualFileFinder.class); this.declarationResolver = new DeclarationResolver(); @@ -186,7 +189,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly this.javaTypeTransformer = new JavaTypeTransformer(); this.deserializedDescriptorResolver = new DeserializedDescriptorResolver(); this.annotationDescriptorDeserializer = new AnnotationDescriptorDeserializer(); - this.javaNamespaceResolver = new JavaNamespaceResolver(); + this.javaPackageFragmentProvider = new JavaPackageFragmentProvider(); this.javaMemberResolver = new JavaMemberResolver(); this.javaConstructorResolver = new JavaConstructorResolver(); this.javaValueParameterResolver = new JavaValueParameterResolver(); @@ -199,9 +202,9 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly this.topDownAnalyzer.setContext(topDownAnalysisContext); this.topDownAnalyzer.setDeclarationResolver(declarationResolver); this.topDownAnalyzer.setModuleDescriptor(moduleDescriptor); - this.topDownAnalyzer.setNamespaceFactory(namespaceFactory); this.topDownAnalyzer.setOverloadResolver(overloadResolver); this.topDownAnalyzer.setOverrideResolver(overrideResolver); + this.topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider); this.topDownAnalyzer.setTopDownAnalysisParameters(topDownAnalysisParameters); this.topDownAnalyzer.setTrace(bindingTrace); this.topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver); @@ -230,10 +233,8 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly this.descriptorResolver.setExpressionTypingServices(expressionTypingServices); this.descriptorResolver.setTypeResolver(typeResolver); - this.javaBridgeConfiguration.setJavaDescriptorResolver(javaDescriptorResolver); - javaDescriptorResolver.setClassResolver(javaClassResolver); - javaDescriptorResolver.setNamespaceResolver(javaNamespaceResolver); + javaDescriptorResolver.setPackageFragmentProvider(javaPackageFragmentProvider); javaClassFinder.setProject(project); @@ -249,8 +250,9 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly virtualFileKotlinClassFinder.setVirtualFileFinder(virtualFileFinder); - this.namespaceFactory.setModuleDescriptor(moduleDescriptor); - this.namespaceFactory.setTrace(bindingTrace); + namespaceFactory.setModule(moduleDescriptor); + namespaceFactory.setPackageFragmentProvider(mutablePackageFragmentProvider); + namespaceFactory.setTrace(bindingTrace); declarationResolver.setAnnotationResolver(annotationResolver); declarationResolver.setContext(topDownAnalysisContext); @@ -330,7 +332,7 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly javaClassResolver.setJavaClassFinder(javaClassFinder); javaClassResolver.setKotlinClassFinder(virtualFileKotlinClassFinder); javaClassResolver.setMemberResolver(javaMemberResolver); - javaClassResolver.setNamespaceResolver(javaNamespaceResolver); + javaClassResolver.setPackageFragmentProvider(javaPackageFragmentProvider); javaClassResolver.setSupertypesResolver(javaSupertypeResolver); javaClassResolver.setTypeParameterResolver(javaTypeParameterResolver); @@ -347,22 +349,22 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly deserializedDescriptorResolver.setAnnotationDeserializer(annotationDescriptorDeserializer); deserializedDescriptorResolver.setErrorReporter(traceBasedErrorReporter); deserializedDescriptorResolver.setJavaClassResolver(javaClassResolver); - deserializedDescriptorResolver.setJavaNamespaceResolver(javaNamespaceResolver); + deserializedDescriptorResolver.setJavaPackageFragmentProvider(javaPackageFragmentProvider); annotationDescriptorDeserializer.setErrorReporter(traceBasedErrorReporter); annotationDescriptorDeserializer.setJavaClassResolver(javaClassResolver); annotationDescriptorDeserializer.setKotlinClassFinder(virtualFileKotlinClassFinder); - javaNamespaceResolver.setCache(traceBasedJavaResolverCache); - javaNamespaceResolver.setDeserializedDescriptorResolver(deserializedDescriptorResolver); - javaNamespaceResolver.setJavaClassFinder(javaClassFinder); - javaNamespaceResolver.setKotlinClassFinder(virtualFileKotlinClassFinder); - javaNamespaceResolver.setMemberResolver(javaMemberResolver); + javaPackageFragmentProvider.setCache(traceBasedJavaResolverCache); + javaPackageFragmentProvider.setDeserializedDescriptorResolver(deserializedDescriptorResolver); + javaPackageFragmentProvider.setJavaClassFinder(javaClassFinder); + javaPackageFragmentProvider.setKotlinClassFinder(virtualFileKotlinClassFinder); + javaPackageFragmentProvider.setMemberResolver(javaMemberResolver); + javaPackageFragmentProvider.setModule(moduleDescriptor); javaMemberResolver.setClassResolver(javaClassResolver); javaMemberResolver.setConstructorResolver(javaConstructorResolver); javaMemberResolver.setFunctionResolver(javaFunctionResolver); - javaMemberResolver.setNamespaceResolver(javaNamespaceResolver); javaMemberResolver.setPropertyResolver(javaPropertyResolver); javaConstructorResolver.setCache(traceBasedJavaResolverCache); @@ -445,8 +447,4 @@ public class InjectorForTopDownAnalyzerForJvm implements InjectorForTopDownAnaly return this.javaBridgeConfiguration; } - public NamespaceFactoryImpl getNamespaceFactory() { - return this.namespaceFactory; - } - } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java index 4c2b38c57f6..91e3069accb 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/AnalyzerFacadeForJVM.java @@ -26,10 +26,9 @@ import org.jetbrains.jet.analyzer.AnalyzerFacade; import org.jetbrains.jet.analyzer.AnalyzerFacadeForEverything; import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver; import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm; -import org.jetbrains.jet.lang.ModuleConfiguration; +import org.jetbrains.jet.lang.DefaultModuleConfiguration; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl; -import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.*; import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap; @@ -38,8 +37,6 @@ import org.jetbrains.jet.lang.resolve.lazy.declarations.FileBasedDeclarationProv import org.jetbrains.jet.lang.resolve.lazy.storage.LockBasedLazyResolveStorageManager; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; -import org.jetbrains.jet.lang.resolve.scopes.JetScope; -import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import java.util.Collection; @@ -90,7 +87,7 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade { @NotNull Collection files, @NotNull BindingTrace trace, @NotNull InjectorForJavaDescriptorResolver injector, - final boolean addBuiltIns + boolean addBuiltIns ) { final JavaClassFinderImpl classFinder = injector.getJavaClassFinder(); @@ -103,30 +100,17 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade { } }); - final JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver(); + JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver(); - ModuleConfiguration moduleConfiguration = new ModuleConfiguration() { - @Override - public void extendNamespaceScope( - @NotNull NamespaceDescriptor namespaceDescriptor, - @NotNull WritableScope namespaceMemberScope - ) { - FqName fqName = DescriptorUtils.getFQName(namespaceDescriptor).toSafe(); - if (KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME.equals(fqName) && addBuiltIns) { - namespaceMemberScope.importScope(KotlinBuiltIns.getInstance().getBuiltInsScope()); - } - if (classFinder.findPackage(fqName) != null) { - JetScope javaPackageScope = javaDescriptorResolver.getJavaPackageScope(namespaceDescriptor); - assert javaPackageScope != null; - namespaceMemberScope.importScope(javaPackageScope); - } - } - }; + ModuleDescriptorImpl module = injector.getModule(); - ModuleDescriptorImpl lazyModule = createJavaModule(""); - lazyModule.setModuleConfiguration(moduleConfiguration); + module.setModuleConfiguration(DefaultModuleConfiguration.INSTANCE); + module.addFragmentProvider(javaDescriptorResolver.getPackageFragmentProvider()); + if (addBuiltIns) { + module.addFragmentProvider(KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider()); + } - return new ResolveSession(project, storageManager, lazyModule, declarationProviderFactory, trace); + return new ResolveSession(project, storageManager, module, declarationProviderFactory, trace); } public static AnalyzeExhaust analyzeOneFileWithJavaIntegrationAndCheckForErrors( @@ -192,7 +176,6 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade { boolean storeContextForBodiesResolve ) { ModuleDescriptorImpl owner = createJavaModule(""); - TopDownAnalysisParameters topDownAnalysisParameters = new TopDownAnalysisParameters( filesToAnalyzeCompletely, false, false, scriptParameters); @@ -206,7 +189,8 @@ public enum AnalyzerFacadeForJVM implements AnalyzerFacade { new CachedBodiesResolveContext(injector.getTopDownAnalysisContext()) : null; return AnalyzeExhaust.success(trace.getBindingContext(), bodiesResolveContext, owner); - } finally { + } + finally { injector.destroy(); } } 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 b0aa43ed7e0..434ab354ff6 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 @@ -17,7 +17,7 @@ package org.jetbrains.jet.lang.resolve.java; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.util.slicedmap.Slices; import org.jetbrains.jet.util.slicedmap.WritableSlice; @@ -32,7 +32,7 @@ public class JavaBindingContext { /** * @see BindingContext#NAMESPACE_IS_SRC */ - public static final WritableSlice JAVA_NAMESPACE_KIND = Slices.createSimpleSlice(); + public static final WritableSlice JAVA_NAMESPACE_KIND = Slices.createSimpleSlice(); public static final WritableSlice> LOAD_FROM_JAVA_SIGNATURE_ERRORS = Slices.createCollectiveSlice(); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TraceBasedJavaResolverCache.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TraceBasedJavaResolverCache.java index 32f5c9a4366..a4e81ec23fa 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TraceBasedJavaResolverCache.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TraceBasedJavaResolverCache.java @@ -64,12 +64,6 @@ public class TraceBasedJavaResolverCache implements JavaResolverCache { return trace.get(FQNAME_TO_CLASS_DESCRIPTOR, fqName); } - @Nullable - @Override - public NamespaceDescriptor getPackageResolvedFromSource(@NotNull FqName fqName) { - return trace.get(FQNAME_TO_NAMESPACE_DESCRIPTOR, fqName); - } - @Nullable @Override public SimpleFunctionDescriptor getMethod(@NotNull JavaMethod method) { @@ -132,17 +126,12 @@ public class TraceBasedJavaResolverCache implements JavaResolverCache { } @Override - public void recordProperNamespace(@NotNull NamespaceDescriptor descriptor) { + public void recordProperPackage(@NotNull PackageFragmentDescriptor descriptor) { trace.record(JavaBindingContext.JAVA_NAMESPACE_KIND, descriptor, JavaNamespaceKind.PROPER); } @Override - public void recordClassStaticMembersNamespace(@NotNull NamespaceDescriptor descriptor) { + public void recordClassStaticMembersNamespace(@NotNull PackageFragmentDescriptor descriptor) { trace.record(JavaBindingContext.JAVA_NAMESPACE_KIND, descriptor, JavaNamespaceKind.CLASS_STATICS); } - - @Override - public void recordPackage(@NotNull JavaElement element, @NotNull NamespaceDescriptor descriptor) { - trace.record(NAMESPACE, ((JavaElementImpl) element).getPsi(), descriptor); - } } diff --git a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorFinder.java b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorFinder.java index 403607ffe56..d4e7b57a517 100644 --- a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorFinder.java +++ b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorFinder.java @@ -19,7 +19,7 @@ package org.jetbrains.jet.descriptors.serialization; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; @@ -34,9 +34,10 @@ public interface DescriptorFinder { return null; } + // TODO 1 remove it, make owner not lazy @Nullable @Override - public NamespaceDescriptor findPackage(@NotNull FqName name) { + public PackageFragmentDescriptor findPackage(@NotNull FqName name) { return null; } @@ -51,7 +52,7 @@ public interface DescriptorFinder { ClassDescriptor findClass(@NotNull ClassId classId); @Nullable - NamespaceDescriptor findPackage(@NotNull FqName name); + PackageFragmentDescriptor findPackage(@NotNull FqName name); @NotNull Collection getClassNames(@NotNull FqName packageName); diff --git a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorSerializer.java b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorSerializer.java index 25fc411e2cc..4b937398c67 100644 --- a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorSerializer.java +++ b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorSerializer.java @@ -16,6 +16,7 @@ package org.jetbrains.jet.descriptors.serialization; +import com.google.common.collect.Lists; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.Annotated; @@ -391,10 +392,15 @@ public class DescriptorSerializer { } @NotNull - public ProtoBuf.Package.Builder packageProto(@NotNull NamespaceDescriptor descriptor) { + public ProtoBuf.Package.Builder packageProto(@NotNull Collection fragments) { ProtoBuf.Package.Builder builder = ProtoBuf.Package.newBuilder(); - for (DeclarationDescriptor declaration : sort(descriptor.getMemberScope().getAllDescriptors())) { + Collection members = Lists.newArrayList(); + for (PackageFragmentDescriptor fragment : fragments) { + members.addAll(fragment.getMemberScope().getAllDescriptors()); + } + + for (DeclarationDescriptor declaration : sort(members)) { if (declaration instanceof PropertyDescriptor || declaration instanceof FunctionDescriptor) { builder.addMember(callableProto((CallableMemberDescriptor) declaration)); } diff --git a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/NameTable.java b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/NameTable.java index cda04195448..d0657e3bf61 100644 --- a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/NameTable.java +++ b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/NameTable.java @@ -18,10 +18,7 @@ package org.jetbrains.jet.descriptors.serialization; import gnu.trove.TObjectHashingStrategy; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.descriptors.ClassOrNamespaceDescriptor; -import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; @@ -78,10 +75,10 @@ public class NameTable { builder.setShortName(getSimpleNameIndex(descriptor.getName())); DeclarationDescriptor containingDeclaration = descriptor.getContainingDeclaration(); - if (containingDeclaration instanceof NamespaceDescriptor) { - NamespaceDescriptor namespaceDescriptor = (NamespaceDescriptor) containingDeclaration; - if (!DescriptorUtils.isRootNamespace(namespaceDescriptor)) { - builder.setParentQualifiedName(getFqNameIndex(namespaceDescriptor)); + if (containingDeclaration instanceof PackageFragmentDescriptor) { + PackageFragmentDescriptor fragment = (PackageFragmentDescriptor) containingDeclaration; + if (!fragment.getFqName().isRoot()) { + builder.setParentQualifiedName(getFqNameIndex(fragment.getFqName())); } } else if (containingDeclaration instanceof ClassDescriptor) { diff --git a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedMemberScope.java b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedMemberScope.java index ba21fcdc239..32bd5862579 100644 --- a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedMemberScope.java +++ b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedMemberScope.java @@ -167,7 +167,7 @@ public abstract class DeserializedMemberScope implements JetScope { @Nullable @Override - public NamespaceDescriptor getNamespace(@NotNull Name name) { + public PackageViewDescriptor getPackage(@NotNull Name name) { return null; } diff --git a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedPackageMemberScope.java b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedPackageMemberScope.java index 104ef1c434b..d8ba0e4cb4b 100644 --- a/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedPackageMemberScope.java +++ b/compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedPackageMemberScope.java @@ -19,11 +19,7 @@ package org.jetbrains.jet.descriptors.serialization.descriptors; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.descriptors.serialization.*; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; -import org.jetbrains.jet.lang.descriptors.ReceiverParameterDescriptor; -import org.jetbrains.jet.lang.resolve.DescriptorUtils; +import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.resolve.name.Name; @@ -38,7 +34,7 @@ public class DeserializedPackageMemberScope extends DeserializedMemberScope { public DeserializedPackageMemberScope( @NotNull StorageManager storageManager, - @NotNull NamespaceDescriptor packageDescriptor, + @NotNull PackageFragmentDescriptor packageDescriptor, @NotNull AnnotationDeserializer annotationDeserializer, @NotNull DescriptorFinder descriptorFinder, @NotNull ProtoBuf.Package proto, @@ -48,12 +44,12 @@ public class DeserializedPackageMemberScope extends DeserializedMemberScope { DescriptorDeserializer.create(storageManager, packageDescriptor, nameResolver, descriptorFinder, annotationDeserializer), proto.getMemberList()); this.descriptorFinder = descriptorFinder; - this.packageFqName = DescriptorUtils.getFQName(packageDescriptor).toSafe(); + this.packageFqName = packageDescriptor.getFqName(); } public DeserializedPackageMemberScope( @NotNull StorageManager storageManager, - @NotNull NamespaceDescriptor packageDescriptor, + @NotNull PackageFragmentDescriptor packageDescriptor, @NotNull AnnotationDeserializer annotationDeserializer, @NotNull DescriptorFinder descriptorFinder, @NotNull PackageData packageData @@ -84,12 +80,6 @@ public class DeserializedPackageMemberScope extends DeserializedMemberScope { // Do nothing } - @Nullable - @Override - public NamespaceDescriptor getNamespace(@NotNull Name name) { - return descriptorFinder.findPackage(packageFqName.child(name)); - } - @Nullable @Override protected ReceiverParameterDescriptor getImplicitReceiver() { diff --git a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java index 2dd5b9aa161..41e7f0e6fd4 100644 --- a/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java +++ b/compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java @@ -28,6 +28,7 @@ import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl; import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolverDummyImpl; +import org.jetbrains.jet.lang.resolve.MutablePackageFragmentProvider; import org.jetbrains.jet.lang.resolve.NamespaceFactoryImpl; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.resolve.DeclarationResolver; @@ -66,6 +67,7 @@ public class InjectorForTopDownAnalyzerBasic { private final BindingTrace bindingTrace; private final ModuleDescriptorImpl moduleDescriptor; private final DependencyClassByQualifiedNameResolverDummyImpl dependencyClassByQualifiedNameResolverDummy; + private final MutablePackageFragmentProvider mutablePackageFragmentProvider; private final NamespaceFactoryImpl namespaceFactory; private final PlatformToKotlinClassMap platformToKotlinClassMap; private final DeclarationResolver declarationResolver; @@ -106,6 +108,7 @@ public class InjectorForTopDownAnalyzerBasic { this.bindingTrace = bindingTrace; this.moduleDescriptor = moduleDescriptor; this.dependencyClassByQualifiedNameResolverDummy = new DependencyClassByQualifiedNameResolverDummyImpl(); + this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(getModuleDescriptor()); this.namespaceFactory = new NamespaceFactoryImpl(); this.platformToKotlinClassMap = platformToKotlinClassMap; this.declarationResolver = new DeclarationResolver(); @@ -131,9 +134,9 @@ public class InjectorForTopDownAnalyzerBasic { this.topDownAnalyzer.setContext(topDownAnalysisContext); this.topDownAnalyzer.setDeclarationResolver(declarationResolver); this.topDownAnalyzer.setModuleDescriptor(moduleDescriptor); - this.topDownAnalyzer.setNamespaceFactory(namespaceFactory); this.topDownAnalyzer.setOverloadResolver(overloadResolver); this.topDownAnalyzer.setOverrideResolver(overrideResolver); + this.topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider); this.topDownAnalyzer.setTopDownAnalysisParameters(topDownAnalysisParameters); this.topDownAnalyzer.setTrace(bindingTrace); this.topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver); @@ -162,7 +165,8 @@ public class InjectorForTopDownAnalyzerBasic { this.descriptorResolver.setExpressionTypingServices(expressionTypingServices); this.descriptorResolver.setTypeResolver(typeResolver); - namespaceFactory.setModuleDescriptor(moduleDescriptor); + namespaceFactory.setModule(moduleDescriptor); + namespaceFactory.setPackageFragmentProvider(mutablePackageFragmentProvider); namespaceFactory.setTrace(bindingTrace); declarationResolver.setAnnotationResolver(annotationResolver); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamespaceHeader.java b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamespaceHeader.java index 383fdb96977..011d1d8042b 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamespaceHeader.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamespaceHeader.java @@ -81,7 +81,7 @@ public class JetNamespaceHeader extends JetReferenceExpression { } @NotNull - public FqName getParentFqName(JetReferenceExpression nameExpression) { + public FqName getParentFqName(JetSimpleNameExpression nameExpression) { String parentQualifiedName = getQualifiedNameParentOf(nameExpression); return parentQualifiedName.isEmpty() ? FqName.ROOT : new FqName(parentQualifiedName); } @@ -96,7 +96,7 @@ public class JetNamespaceHeader extends JetReferenceExpression { } @NotNull - private String getQualifiedNameParentOf(@Nullable JetReferenceExpression nameExpression) { + private String getQualifiedNameParentOf(@Nullable JetSimpleNameExpression nameExpression) { StringBuilder builder = new StringBuilder(); for (JetSimpleNameExpression e : findChildrenByClass(JetSimpleNameExpression.class)) { if (e == nameExpression) { 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 1ce21d0518d..dd5df20b265 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java @@ -196,8 +196,6 @@ public interface BindingContext { } }; - WritableSlice NAMESPACE = Slices.sliceBuilder() - .setOpposite((WritableSlice) BindingContextUtils.DESCRIPTOR_TO_DECLARATION).build(); WritableSlice CLASS = Slices.sliceBuilder().setOpposite((WritableSlice) BindingContextUtils.DESCRIPTOR_TO_DECLARATION) .build(); @@ -229,7 +227,7 @@ public interface BindingContext { .build(); WritableSlice[] DECLARATIONS_TO_DESCRIPTORS = new WritableSlice[] { - NAMESPACE, CLASS, TYPE_PARAMETER, FUNCTION, CONSTRUCTOR, VARIABLE, VALUE_PARAMETER, PROPERTY_ACCESSOR, + CLASS, TYPE_PARAMETER, FUNCTION, CONSTRUCTOR, VARIABLE, VALUE_PARAMETER, PROPERTY_ACCESSOR, PRIMARY_CONSTRUCTOR_PARAMETER }; @@ -248,15 +246,11 @@ public interface BindingContext { Slices.sliceBuilder().build(); WritableSlice FQNAME_TO_CLASS_DESCRIPTOR = new BasicWritableSlice(DO_NOTHING, true); + @Deprecated WritableSlice FQNAME_TO_NAMESPACE_DESCRIPTOR = new BasicWritableSlice(DO_NOTHING); - WritableSlice FILE_TO_NAMESPACE = Slices.createSimpleSlice(); - WritableSlice> NAMESPACE_TO_FILES = Slices.createSimpleSlice(); - - /** - * Each namespace found in src must be registered here. - */ - WritableSlice NAMESPACE_IS_SRC = Slices.createSimpleSlice(); + WritableSlice FILE_TO_PACKAGE_FRAGMENT = Slices.createSimpleSlice(); + WritableSlice> PACKAGE_TO_FILES = Slices.createSimpleSlice(); WritableSlice INCOMPLETE_HIERARCHY = Slices.createCollectiveSetSlice(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java index b951750c5f3..53b86ee8497 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java @@ -22,13 +22,11 @@ import com.google.common.collect.*; import com.intellij.lang.ASTNode; import com.intellij.openapi.util.Pair; import com.intellij.psi.PsiElement; +import com.intellij.util.containers.ContainerUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptor; -import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptorLite; -import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorImpl; -import org.jetbrains.jet.lang.descriptors.impl.NamespaceLikeBuilder; +import org.jetbrains.jet.lang.descriptors.impl.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; @@ -96,13 +94,13 @@ public class DeclarationResolver { resolveAnnotationStubsOnClassesAndConstructors(); resolveFunctionAndPropertyHeaders(); createFunctionsForDataClasses(); - importsResolver.processMembersImports(rootScope); + importsResolver.processMembersImports(); checkRedeclarationsInNamespaces(); checkRedeclarationsInInnerClassNames(); } private void checkModifiersAndAnnotationsInNamespaceHeaders() { - for (JetFile file : context.getNamespaceDescriptors().keySet()) { + for (JetFile file : context.getPackageFragments().keySet()) { JetNamespaceHeader namespaceHeader = file.getNamespaceHeader(); if (namespaceHeader == null) continue; @@ -163,7 +161,7 @@ public class DeclarationResolver { for (Map.Entry entry : context.getNamespaceScopes().entrySet()) { JetFile namespace = entry.getKey(); WritableScope namespaceScope = entry.getValue(); - NamespaceLikeBuilder namespaceDescriptor = context.getNamespaceDescriptors().get(namespace).getBuilder(); + NamespaceLikeBuilder namespaceDescriptor = context.getPackageFragments().get(namespace).getBuilder(); resolveFunctionAndPropertyHeaders(namespace.getDeclarations(), namespaceScope, namespaceScope, namespaceScope, namespaceDescriptor); } @@ -312,8 +310,10 @@ public class DeclarationResolver { } private void checkRedeclarationsInNamespaces() { - for (NamespaceDescriptorImpl descriptor : Sets.newHashSet(context.getNamespaceDescriptors().values())) { - Multimap simpleNameDescriptors = descriptor.getMemberScope().getDeclaredDescriptorsAccessibleBySimpleName(); + for (MutablePackageFragmentDescriptor packageFragment : Sets.newHashSet(context.getPackageFragments().values())) { + PackageViewDescriptor packageView = packageFragment.getContainingDeclaration().getPackage(packageFragment.getFqName()); + JetScope packageViewScope = packageView.getMemberScope(); + Multimap simpleNameDescriptors = packageFragment.getMemberScope().getDeclaredDescriptorsAccessibleBySimpleName(); for (Name name : simpleNameDescriptors.keySet()) { // Keep only properties with no receiver Collection descriptors = Collections2.filter(simpleNameDescriptors.get(name), new Predicate() { @@ -326,6 +326,8 @@ public class DeclarationResolver { return true; } }); + ContainerUtil.addIfNotNull(descriptors, packageViewScope.getPackage(name)); + if (descriptors.size() > 1) { for (DeclarationDescriptor declarationDescriptor : descriptors) { for (PsiElement declaration : getDeclarationsByDescriptor(declarationDescriptor)) { @@ -341,18 +343,18 @@ public class DeclarationResolver { private Collection getDeclarationsByDescriptor(DeclarationDescriptor declarationDescriptor) { Collection declarations; - if (declarationDescriptor instanceof NamespaceDescriptor) { - final NamespaceDescriptor namespace = (NamespaceDescriptor)declarationDescriptor; - Collection files = trace.get(BindingContext.NAMESPACE_TO_FILES, namespace); + if (declarationDescriptor instanceof PackageViewDescriptor) { + final PackageViewDescriptor aPackage = (PackageViewDescriptor)declarationDescriptor; + Collection files = trace.get(BindingContext.PACKAGE_TO_FILES, aPackage.getFqName()); if (files == null) { - throw new IllegalStateException("declarations corresponding to " + namespace + " are not found"); + throw new IllegalStateException("declarations corresponding to " + aPackage + " are not found"); } declarations = Collections2.transform(files, new Function() { @Override public PsiElement apply(@Nullable JetFile file) { - assert file != null : "File is null for namespace " + namespace; + assert file != null : "File is null for aPackage " + aPackage; return file.getNamespaceHeader().getNameIdentifier(); } }); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/Importer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/Importer.java index dc620dd96de..861f20d029d 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/Importer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/Importer.java @@ -88,8 +88,8 @@ public interface Importer { protected void importAllUnderDeclaration(@NotNull DeclarationDescriptor descriptor, @NotNull PlatformToKotlinClassMap platformToKotlinClassMap) { List scopesToImport = new ArrayList(2); - if (descriptor instanceof NamespaceDescriptor) { - scopesToImport.add(((NamespaceDescriptor) descriptor).getMemberScope()); + if (descriptor instanceof PackageViewDescriptor) { + scopesToImport.add(((PackageViewDescriptor) descriptor).getMemberScope()); } else if (descriptor instanceof ClassDescriptor && ((ClassDescriptor) descriptor).getKind() != ClassKind.OBJECT) { ClassDescriptor classDescriptor = (ClassDescriptor) descriptor; @@ -109,8 +109,8 @@ public interface Importer { if (descriptor instanceof ClassifierDescriptor) { namespaceScope.importClassifierAlias(aliasName, (ClassifierDescriptor) descriptor); } - else if (descriptor instanceof NamespaceDescriptor) { - namespaceScope.importNamespaceAlias(aliasName, (NamespaceDescriptor) descriptor); + else if (descriptor instanceof PackageViewDescriptor) { + namespaceScope.importPackageAlias(aliasName, (PackageViewDescriptor) descriptor); } else if (descriptor instanceof FunctionDescriptor) { namespaceScope.importFunctionAlias(aliasName, (FunctionDescriptor) descriptor); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java index 99faa880ad9..4158b07464b 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java @@ -22,6 +22,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.*; +import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; @@ -71,39 +72,39 @@ public class ImportsResolver { this.importsFactory = importsFactory; } - public void processTypeImports(@NotNull JetScope rootScope) { - processImports(LookupMode.ONLY_CLASSES, rootScope); + public void processTypeImports() { + processImports(LookupMode.ONLY_CLASSES); } - public void processMembersImports(@NotNull JetScope rootScope) { - processImports(LookupMode.EVERYTHING, rootScope); + public void processMembersImports() { + processImports(LookupMode.EVERYTHING); } - private void processImports(@NotNull LookupMode lookupMode, @NotNull JetScope rootScope) { - for (JetFile file : context.getNamespaceDescriptors().keySet()) { + private void processImports(@NotNull LookupMode lookupMode) { + for (JetFile file : context.getPackageFragments().keySet()) { WritableScope namespaceScope = context.getNamespaceScopes().get(file); - processImportsInFile(lookupMode, namespaceScope, Lists.newArrayList(file.getImportDirectives()), rootScope); + processImportsInFile(lookupMode, namespaceScope, Lists.newArrayList(file.getImportDirectives())); } for (JetScript script : context.getScripts().keySet()) { WritableScope scriptScope = context.getScriptScopes().get(script); - processImportsInFile(lookupMode, scriptScope, script.getImportDirectives(), rootScope); + processImportsInFile(lookupMode, scriptScope, script.getImportDirectives()); } } - private void processImportsInFile(@NotNull LookupMode lookupMode, WritableScope scope, List directives, JetScope rootScope) { - processImportsInFile(lookupMode, scope, directives, rootScope, moduleDescriptor, trace, qualifiedExpressionResolver, importsFactory); + private void processImportsInFile(@NotNull LookupMode lookupMode, WritableScope scope, List directives) { + processImportsInFile(lookupMode, scope, directives, moduleDescriptor, trace, qualifiedExpressionResolver, importsFactory); } - public static void processImportsInFile( + private static void processImportsInFile( LookupMode lookupMode, @NotNull WritableScope namespaceScope, @NotNull List importDirectives, - @NotNull JetScope rootScope, @NotNull ModuleDescriptor module, @NotNull BindingTrace trace, @NotNull QualifiedExpressionResolver qualifiedExpressionResolver, @NotNull JetImportsFactory importsFactory ) { + @NotNull JetScope rootScope = module.getPackage(FqName.ROOT).getMemberScope(); Importer.DelayedImporter delayedImporter = new Importer.DelayedImporter(namespaceScope); if (lookupMode == LookupMode.EVERYTHING) { @@ -185,10 +186,10 @@ public class ImportsResolver { else if (wasResolved instanceof VariableDescriptor) { isResolved = namespaceScope.getLocalVariable(aliasName); } - else if (wasResolved instanceof NamespaceDescriptor) { - isResolved = namespaceScope.getNamespace(aliasName); + else if (wasResolved instanceof PackageViewDescriptor) { + isResolved = namespaceScope.getPackage(aliasName); } - if (isResolved == null || isResolved == wasResolved) { + if (isResolved == null || isResolved.equals(wasResolved)) { uselessHiddenImport = false; } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ModifiersChecker.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ModifiersChecker.java index 24da8528e74..9f71a1a98cb 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ModifiersChecker.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ModifiersChecker.java @@ -89,7 +89,7 @@ public class ModifiersChecker { if (modifierList == null) return; DeclarationDescriptor containingDeclaration = descriptor.getContainingDeclaration(); - if (containingDeclaration instanceof NamespaceDescriptor) { + if (containingDeclaration instanceof PackageFragmentDescriptor) { if (modifierList.hasModifier(PROTECTED_KEYWORD)) { trace.report(Errors.PACKAGE_MEMBER_CANNOT_BE_PROTECTED.on(modifierList.getModifierNode(PROTECTED_KEYWORD).getPsi())); } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/MutablePackageFragmentProvider.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/MutablePackageFragmentProvider.java new file mode 100644 index 00000000000..a6a9e401ca7 --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/MutablePackageFragmentProvider.java @@ -0,0 +1,59 @@ +package org.jetbrains.jet.lang.resolve; + +import com.google.common.collect.Maps; +import com.google.common.collect.Multimap; +import com.intellij.util.containers.ContainerUtil; +import com.intellij.util.containers.MultiMap; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; +import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor; +import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider; +import org.jetbrains.jet.lang.descriptors.impl.MutablePackageFragmentDescriptor; +import org.jetbrains.jet.lang.resolve.name.FqName; + +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import java.util.Map; + +public class MutablePackageFragmentProvider implements PackageFragmentProvider { + private final ModuleDescriptor module; + + private final Map fqNameToPackage = Maps.newHashMap(); + private final MultiMap subPackages = MultiMap.create(); + + public MutablePackageFragmentProvider(@NotNull ModuleDescriptor module) { + this.module = module; + fqNameToPackage.put(FqName.ROOT, new MutablePackageFragmentDescriptor(module, FqName.ROOT)); + } + + @NotNull + @Override + public List getPackageFragments(@NotNull FqName fqName) { + return ContainerUtil.createMaybeSingletonList(fqNameToPackage.get(fqName)); + } + + @NotNull + @Override + public Collection getSubPackagesOf(@NotNull FqName fqName) { + return subPackages.get(fqName); + } + + @NotNull + public MutablePackageFragmentDescriptor getOrCreateFragment(@NotNull FqName fqName) { + if (!fqNameToPackage.containsKey(fqName)) { + FqName parent = fqName.parent(); + getOrCreateFragment(parent); // assure that parent exists + + fqNameToPackage.put(fqName, new MutablePackageFragmentDescriptor(module, fqName)); + subPackages.putValue(parent, fqName); + } + + return fqNameToPackage.get(fqName); + } + + @NotNull + public ModuleDescriptor getModule() { + return module; + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/NamespaceFactory.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/NamespaceFactory.java index 5c2ab1882f0..f039640d763 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/NamespaceFactory.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/NamespaceFactory.java @@ -17,10 +17,11 @@ package org.jetbrains.jet.lang.resolve; import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor; import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorImpl; import org.jetbrains.jet.lang.resolve.name.FqName; public interface NamespaceFactory { @NotNull - NamespaceDescriptorImpl createNamespaceDescriptorPathIfNeeded(@NotNull FqName fqName); + PackageFragmentDescriptor createNamespaceDescriptorPathIfNeeded(@NotNull FqName fqName); } 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 ac73605a5ed..25e09395514 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/NamespaceFactoryImpl.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/NamespaceFactoryImpl.java @@ -17,40 +17,35 @@ package org.jetbrains.jet.lang.resolve; import com.google.common.collect.Sets; -import com.intellij.psi.PsiElement; +import com.intellij.util.containers.ContainerUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl; -import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; -import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; -import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorImpl; -import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorParent; +import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor; +import org.jetbrains.jet.lang.descriptors.impl.MutablePackageFragmentDescriptor; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetNamespaceHeader; import org.jetbrains.jet.lang.psi.JetReferenceExpression; import org.jetbrains.jet.lang.psi.JetSimpleNameExpression; import org.jetbrains.jet.lang.resolve.name.FqName; -import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; -import org.jetbrains.jet.lang.resolve.name.Name; -import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler; -import org.jetbrains.jet.lang.resolve.scopes.WritableScope; -import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl; import javax.inject.Inject; +import java.util.ArrayList; import java.util.Collection; -import java.util.Collections; +import java.util.List; import static org.jetbrains.jet.lang.resolve.BindingContext.*; public class NamespaceFactoryImpl implements NamespaceFactory { - private ModuleDescriptorImpl moduleDescriptor; + private ModuleDescriptorImpl module; + private MutablePackageFragmentProvider packageFragmentProvider; private BindingTrace trace; @Inject - public void setModuleDescriptor(ModuleDescriptorImpl moduleDescriptor) { - this.moduleDescriptor = moduleDescriptor; + public void setModule(ModuleDescriptorImpl module) { + this.module = module; } @Inject @@ -58,160 +53,72 @@ public class NamespaceFactoryImpl implements NamespaceFactory { this.trace = trace; } + @Inject + public void setPackageFragmentProvider(MutablePackageFragmentProvider packageFragmentProvider) { + this.packageFragmentProvider = packageFragmentProvider; + } + @NotNull - public NamespaceDescriptorImpl createNamespaceDescriptorPathIfNeeded(@NotNull JetFile file, - @NotNull JetScope outerScope, - @NotNull RedeclarationHandler handler) { + public MutablePackageFragmentDescriptor createPackageFragmentIfNeeded(@NotNull JetFile file, @NotNull RedeclarationHandler handler) { JetNamespaceHeader namespaceHeader = file.getNamespaceHeader(); - if (moduleDescriptor.getRootNamespaceDescriptorImpl() == null) { - createRootNamespaceDescriptorIfNeeded(null, moduleDescriptor, null, handler); + // TODO 2 make this code neater + List allNamespaceNames = new ArrayList(namespaceHeader.getParentNamespaceNames()); + ContainerUtil.addIfNotNull(allNamespaceNames, namespaceHeader.getLastPartExpression()); + for (JetSimpleNameExpression nameExpression : allNamespaceNames) { + FqName parentFqName = namespaceHeader.getParentFqName(nameExpression); + getOrCreatePackageFragment(parentFqName, nameExpression, handler); + + trace.record(RESOLUTION_SCOPE, nameExpression, module.getPackage(parentFqName).getMemberScope()); } - NamespaceDescriptorImpl currentOwner = moduleDescriptor.getRootNamespaceDescriptorImpl(); - if (currentOwner == null) { - throw new IllegalStateException("must be initialized 5 lines above"); - } - - for (JetSimpleNameExpression nameExpression : namespaceHeader.getParentNamespaceNames()) { - Name namespaceName = Name.identifier(nameExpression.getReferencedName()); - - NamespaceDescriptorImpl namespaceDescriptor = createNamespaceDescriptorIfNeeded( - null, currentOwner, namespaceName, nameExpression, handler); - - trace.record(BindingContext.NAMESPACE_IS_SRC, namespaceDescriptor, true); - trace.record(RESOLUTION_SCOPE, nameExpression, outerScope); - - outerScope = namespaceDescriptor.getMemberScope(); - currentOwner = namespaceDescriptor; - } - - NamespaceDescriptorImpl namespaceDescriptor; - Name name; - if (namespaceHeader.isRoot()) { - // previous call to createRootNamespaceDescriptorIfNeeded couldn't store occurrence for current file. - namespaceDescriptor = moduleDescriptor.getRootNamespaceDescriptorImpl(); - storeBindingForFileAndExpression(file, null, namespaceDescriptor); - } - else { - name = namespaceHeader.getNameAsName(); - namespaceDescriptor = createNamespaceDescriptorIfNeeded( - file, currentOwner, name, namespaceHeader.getLastPartExpression(), handler); - - trace.record(RESOLUTION_SCOPE, namespaceHeader, outerScope); - } - trace.record(BindingContext.NAMESPACE_IS_SRC, namespaceDescriptor, true); - - return namespaceDescriptor; + MutablePackageFragmentDescriptor fragment = getOrCreatePackageFragment( + namespaceHeader.getFqName(), namespaceHeader.getLastPartExpression(), handler); + storeBindingForFile(file, fragment); + return fragment; } @Override @NotNull - public NamespaceDescriptorImpl createNamespaceDescriptorPathIfNeeded(@NotNull FqName fqName) { - NamespaceDescriptorImpl owner = null; + public PackageFragmentDescriptor createNamespaceDescriptorPathIfNeeded(@NotNull FqName fqName) { for (FqName pathElement : fqName.path()) { if (pathElement.isRoot()) { - owner = createRootNamespaceDescriptorIfNeeded(null, - moduleDescriptor, - null, - RedeclarationHandler.DO_NOTHING); + getOrCreatePackageFragment(FqName.ROOT, null, RedeclarationHandler.DO_NOTHING); } else { - assert owner != null : "Should never be null as first element in the path must be root"; - owner = createNamespaceDescriptorIfNeeded(null, - owner, - pathElement.shortName(), - null, - RedeclarationHandler.DO_NOTHING); + getOrCreatePackageFragment(pathElement, null, RedeclarationHandler.DO_NOTHING); } } - - assert owner != null : "Should never be null as first element in the path must be root"; - return owner; - } - - private NamespaceDescriptorImpl createRootNamespaceDescriptorIfNeeded(@Nullable JetFile file, - @NotNull ModuleDescriptorImpl owner, - @Nullable JetReferenceExpression expression, - @NotNull RedeclarationHandler handler) { - FqName fqName = FqName.ROOT; - NamespaceDescriptorImpl namespaceDescriptor = owner.getRootNamespaceDescriptorImpl(); - - if (namespaceDescriptor == null) { - namespaceDescriptor = createNewNamespaceDescriptor(owner, FqNameUnsafe.ROOT_NAME, expression, handler, fqName); - } - - storeBindingForFileAndExpression(file, expression, namespaceDescriptor); - - return namespaceDescriptor; + return packageFragmentProvider.getOrCreateFragment(fqName); } @NotNull - private NamespaceDescriptorImpl createNamespaceDescriptorIfNeeded(@Nullable JetFile file, - @NotNull NamespaceDescriptorImpl owner, - @NotNull Name name, - @Nullable JetReferenceExpression expression, - @NotNull RedeclarationHandler handler) { - FqName ownerFqName = DescriptorUtils.getFQName(owner).toSafe(); - FqName fqName = ownerFqName.child(name); - // !!! - NamespaceDescriptorImpl namespaceDescriptor = (NamespaceDescriptorImpl) owner.getMemberScope().getDeclaredNamespace(name); - - if (namespaceDescriptor == null) { - namespaceDescriptor = createNewNamespaceDescriptor(owner, name, expression, handler, fqName); + private MutablePackageFragmentDescriptor getOrCreatePackageFragment( + @NotNull FqName fqName, + @Nullable JetReferenceExpression expression, + @NotNull RedeclarationHandler handler + ) { + // TODO 1 use handler + MutablePackageFragmentDescriptor fragment = packageFragmentProvider.getOrCreateFragment(fqName); + if (expression != null) { + trace.record(REFERENCE_TARGET, expression, packageFragmentProvider.getModule().getPackage(fqName)); } - storeBindingForFileAndExpression(file, expression, namespaceDescriptor); - - return namespaceDescriptor; + return fragment; } - private NamespaceDescriptorImpl createNewNamespaceDescriptor(NamespaceDescriptorParent owner, - Name name, - PsiElement expression, - RedeclarationHandler handler, - FqName fqName) { - NamespaceDescriptorImpl namespaceDescriptor; - namespaceDescriptor = new NamespaceDescriptorImpl( - owner, - Collections.emptyList(), // TODO: annotations - name - ); - trace.record(FQNAME_TO_NAMESPACE_DESCRIPTOR, fqName, namespaceDescriptor); + private void storeBindingForFile(@NotNull JetFile file, @NotNull PackageFragmentDescriptor fragment) { + trace.record(BindingContext.FILE_TO_PACKAGE_FRAGMENT, file, fragment); - WritableScopeImpl scope = new WritableScopeImpl(JetScope.EMPTY, namespaceDescriptor, handler, "Namespace member scope"); - scope.changeLockLevel(WritableScope.LockLevel.BOTH); - - namespaceDescriptor.initialize(scope); - scope.changeLockLevel(WritableScope.LockLevel.BOTH); - // - moduleDescriptor.getModuleConfiguration().extendNamespaceScope(namespaceDescriptor, scope); - owner.addNamespace(namespaceDescriptor); - if (expression != null) { - trace.record(BindingContext.NAMESPACE, expression, namespaceDescriptor); - } - return namespaceDescriptor; - } - - private void storeBindingForFileAndExpression(@Nullable JetFile file, - @Nullable JetReferenceExpression expression, - @NotNull NamespaceDescriptor namespaceDescriptor) { - if (expression != null) { - trace.record(REFERENCE_TARGET, expression, namespaceDescriptor); - } - - if (file != null) { - trace.record(BindingContext.FILE_TO_NAMESPACE, file, namespaceDescriptor); - - // Register files corresponding to this namespace - // The trace currently does not support bi-di multimaps that would handle this task nicer - Collection files = trace.get(NAMESPACE_TO_FILES, namespaceDescriptor); - if (files == null) { - files = Sets.newIdentityHashSet(); - } - files.add(file); - trace.record(BindingContext.NAMESPACE_TO_FILES, namespaceDescriptor, files); + // Register files corresponding to this namespace + // The trace currently does not support bi-di multimaps that would handle this task nicer + FqName fqName = fragment.getFqName(); + Collection files = trace.get(PACKAGE_TO_FILES, fqName); + if (files == null) { + files = Sets.newIdentityHashSet(); } + files.add(file); + trace.record(BindingContext.PACKAGE_TO_FILES, fqName, files); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java index bc58218ab11..c2a4041d58d 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java @@ -66,12 +66,12 @@ public class OverloadResolver { } private static class Key extends Pair { - Key(String namespace, Name name) { - super(namespace, name); + Key(String packageName, Name name) { + super(packageName, name); } - Key(NamespaceDescriptor namespaceDescriptor, Name name) { - this(DescriptorUtils.getFQName(namespaceDescriptor).asString(), name); + Key(PackageFragmentDescriptor fragment, Name name) { + this(fragment.getFqName().asString(), name); } public String getNamespace() { @@ -88,7 +88,7 @@ public class OverloadResolver { constructorsGrouped() { MultiMap inClasses = MultiMap.create(); - MultiMap inNamespaces = MultiMap.create(); + MultiMap inPackages = MultiMap.create(); for (MutableClassDescriptor klass : context.getClasses().values()) { if (klass.getKind().isSingleton()) { @@ -96,9 +96,9 @@ public class OverloadResolver { continue; } DeclarationDescriptor containingDeclaration = klass.getContainingDeclaration(); - if (containingDeclaration instanceof NamespaceDescriptor) { - NamespaceDescriptor namespaceDescriptor = (NamespaceDescriptor) containingDeclaration; - inNamespaces.put(new Key(namespaceDescriptor, klass.getName()), klass.getConstructors()); + if (containingDeclaration instanceof PackageFragmentDescriptor) { + PackageFragmentDescriptor packageFragment = (PackageFragmentDescriptor) containingDeclaration; + inPackages.put(new Key(packageFragment, klass.getName()), klass.getConstructors()); } else if (containingDeclaration instanceof ClassDescriptor) { ClassDescriptor classDescriptor = (ClassDescriptor) containingDeclaration; @@ -109,7 +109,7 @@ public class OverloadResolver { } } - return Pair.create(inClasses, inNamespaces); + return Pair.create(inClasses, inPackages); } private void checkOverloadsInANamespace(MultiMap inNamespaces) { @@ -118,17 +118,17 @@ public class OverloadResolver { for (SimpleFunctionDescriptor function : context.getFunctions().values()) { DeclarationDescriptor containingDeclaration = function.getContainingDeclaration(); - if (containingDeclaration instanceof NamespaceDescriptor) { - NamespaceDescriptor namespaceDescriptor = (NamespaceDescriptor) containingDeclaration; - functionsByName.putValue(new Key(namespaceDescriptor, function.getName()), function); + if (containingDeclaration instanceof PackageFragmentDescriptor) { + PackageFragmentDescriptor packageFragment = (PackageFragmentDescriptor) containingDeclaration; + functionsByName.putValue(new Key(packageFragment, function.getName()), function); } } for (PropertyDescriptor property : context.getProperties().values()) { DeclarationDescriptor containingDeclaration = property.getContainingDeclaration(); - if (containingDeclaration instanceof NamespaceDescriptor) { - NamespaceDescriptor namespaceDescriptor = (NamespaceDescriptor) containingDeclaration; - functionsByName.putValue(new Key(namespaceDescriptor, property.getName()), property); + if (containingDeclaration instanceof PackageFragmentDescriptor) { + PackageFragmentDescriptor packageFragment = (PackageFragmentDescriptor) containingDeclaration; + functionsByName.putValue(new Key(packageFragment, property.getName()), property); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/QualifiedExpressionResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/QualifiedExpressionResolver.java index da722783298..4100e141cf3 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/QualifiedExpressionResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/QualifiedExpressionResolver.java @@ -38,7 +38,7 @@ public class QualifiedExpressionResolver { private static final Predicate CLASSIFIERS_AND_NAMESPACES = new Predicate() { @Override public boolean apply(@Nullable DeclarationDescriptor descriptor) { - return descriptor instanceof ClassifierDescriptor || descriptor instanceof NamespaceDescriptor; + return descriptor instanceof ClassifierDescriptor || descriptor instanceof PackageViewDescriptor; } }; @@ -144,7 +144,7 @@ public class QualifiedExpressionResolver { ) { assert lookupMode == LookupMode.EVERYTHING; - if (descriptor instanceof NamespaceDescriptor) { + if (descriptor instanceof PackageViewDescriptor) { return true; } if (descriptor instanceof ClassDescriptor && !((ClassDescriptor)descriptor).getKind().isSingleton()) { @@ -211,8 +211,8 @@ public class QualifiedExpressionResolver { Set results = Sets.newHashSet(); for (DeclarationDescriptor declarationDescriptor : declarationDescriptors) { - if (declarationDescriptor instanceof NamespaceDescriptor) { - addResult(results, lookupSimpleNameReference(selector, ((NamespaceDescriptor)declarationDescriptor).getMemberScope(), + if (declarationDescriptor instanceof PackageViewDescriptor) { + addResult(results, lookupSimpleNameReference(selector, ((PackageViewDescriptor)declarationDescriptor).getMemberScope(), lookupMode, true)); } if (declarationDescriptor instanceof ClassDescriptor) { @@ -256,9 +256,9 @@ public class QualifiedExpressionResolver { Name referencedName = referenceExpression.getReferencedNameAsName(); Set descriptors = Sets.newHashSet(); - NamespaceDescriptor namespaceDescriptor = outerScope.getNamespace(referencedName); - if (namespaceDescriptor != null) { - descriptors.add(namespaceDescriptor); + PackageViewDescriptor packageDescriptor = outerScope.getPackage(referencedName); + if (packageDescriptor != null) { + descriptors.add(packageDescriptor); } ClassifierDescriptor classifierDescriptor = outerScope.getClassifier(referencedName); @@ -389,20 +389,20 @@ public class QualifiedExpressionResolver { @NotNull JetScope scopeToCheckVisibility) { if (filteredDescriptors.size() == 2) { - NamespaceDescriptor namespaceDescriptor = null; + PackageViewDescriptor packageView = null; ClassDescriptor classDescriptor = null; for (DeclarationDescriptor filteredDescriptor : filteredDescriptors) { - if (filteredDescriptor instanceof NamespaceDescriptor) { - namespaceDescriptor = (NamespaceDescriptor)filteredDescriptor; + if (filteredDescriptor instanceof PackageViewDescriptor) { + packageView = (PackageViewDescriptor)filteredDescriptor; } else if (filteredDescriptor instanceof ClassDescriptor) { classDescriptor = (ClassDescriptor)filteredDescriptor; } } - if (namespaceDescriptor != null && classDescriptor != null) { - if (DescriptorUtils.getFQName(namespaceDescriptor).equalsTo(DescriptorUtils.getFQName(classDescriptor))) { + if (packageView != null && classDescriptor != null) { + if (DescriptorUtils.getFQName(packageView).equalsTo(DescriptorUtils.getFQName(classDescriptor))) { trace.record(BindingContext.REFERENCE_TARGET, referenceExpression, classDescriptor); trace.record(BindingContext.RESOLUTION_SCOPE, referenceExpression, resolutionScope); checkVisibility(classDescriptor, trace, referenceExpression, scopeToCheckVisibility); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ScriptHeaderResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ScriptHeaderResolver.java index e07e7394b64..b68d3f5cdef 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ScriptHeaderResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ScriptHeaderResolver.java @@ -20,6 +20,7 @@ import com.google.common.collect.Lists; import com.intellij.openapi.util.Key; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; +import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor; import org.jetbrains.jet.lang.descriptors.ScriptDescriptor; import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; @@ -121,7 +122,7 @@ public class ScriptHeaderResolver { JetFile file = (JetFile) script.getContainingFile(); JetNamespaceHeader namespaceHeader = file.getNamespaceHeader(); FqName fqName = namespaceHeader != null ? new FqName(namespaceHeader.getQualifiedName()) : FqName.ROOT; - NamespaceDescriptorImpl ns = namespaceFactory.createNamespaceDescriptorPathIfNeeded(fqName); + PackageFragmentDescriptor ns = namespaceFactory.createNamespaceDescriptorPathIfNeeded(fqName); Integer priority = script.getUserData(PRIORITY_KEY); if (priority == null) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java index 1cc96234617..cc7dd06e345 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java @@ -25,7 +25,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptor; import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptorLite; -import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorImpl; +import org.jetbrains.jet.lang.descriptors.impl.MutablePackageFragmentDescriptor; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.scopes.JetScope; @@ -42,7 +42,7 @@ public class TopDownAnalysisContext implements BodiesResolveContext { private DataFlowInfo outerDataFlowInfo = DataFlowInfo.EMPTY; private final Map classes = Maps.newLinkedHashMap(); - protected final Map namespaceDescriptors = Maps.newHashMap(); + protected final Map packageFragments = Maps.newHashMap(); private List classesTopologicalOrder = null; private final Map declaringScopes = Maps.newHashMap(); @@ -114,13 +114,13 @@ public class TopDownAnalysisContext implements BodiesResolveContext { return namespaceScopes; } - public Map getNamespaceDescriptors() { - return namespaceDescriptors; + public Map getPackageFragments() { + return packageFragments; } @Override public Collection getFiles() { - return namespaceDescriptors.keySet(); + return packageFragments.keySet(); } @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java index 57058b1ff5e..7a0a255112c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java @@ -33,7 +33,6 @@ import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.WritableScope; -import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl; import org.jetbrains.jet.lang.types.expressions.ExpressionTypingContext; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; @@ -59,7 +58,7 @@ public class TopDownAnalyzer { @NotNull private ModuleDescriptor moduleDescriptor; @NotNull - private NamespaceFactoryImpl namespaceFactory; + private MutablePackageFragmentProvider packageFragmentProvider; @NotNull private BodyResolver bodyResolver; @@ -104,8 +103,8 @@ public class TopDownAnalyzer { } @Inject - public void setNamespaceFactory(@NotNull NamespaceFactoryImpl namespaceFactory) { - this.namespaceFactory = namespaceFactory; + public void setPackageFragmentProvider(@NotNull MutablePackageFragmentProvider packageFragmentProvider) { + this.packageFragmentProvider = packageFragmentProvider; } @Inject @@ -168,8 +167,9 @@ public class TopDownAnalyzer { private void doProcessStandardLibraryNamespace( WritableScope outerScope, NamespaceDescriptorImpl standardLibraryNamespace, List files) { ArrayList toAnalyze = new ArrayList(); - for(JetFile file : files) { - context.getNamespaceDescriptors().put(file, standardLibraryNamespace); + for (JetFile file : files) { + // TODO 1 restore + //context.getPackageFragments().put(file, standardLibraryNamespace); context.getNamespaceScopes().put(file, standardLibraryNamespace.getMemberScope()); toAnalyze.addAll(file.getDeclarations()); } @@ -231,27 +231,19 @@ public class TopDownAnalyzer { public void analyzeFiles( @NotNull Collection files, @NotNull List scriptParameters) { - WritableScope scope = new WritableScopeImpl( - JetScope.EMPTY, moduleDescriptor, - new TraceBasedRedeclarationHandler(trace), "Root scope in analyzeNamespace"); + ((ModuleDescriptorImpl) moduleDescriptor).addFragmentProvider(packageFragmentProvider); - scope.changeLockLevel(WritableScope.LockLevel.BOTH); - - NamespaceDescriptorImpl rootNs = namespaceFactory.createNamespaceDescriptorPathIfNeeded(FqName.ROOT); - - // map "jet" namespace into KotlinBuiltIns - // @see DefaultModuleConfiguraiton#extendNamespaceScope - namespaceFactory.createNamespaceDescriptorPathIfNeeded(KotlinBuiltIns.getInstance().getBuiltInsPackageFqName()); + // "depend on" builtins module + ((ModuleDescriptorImpl) moduleDescriptor).addFragmentProvider(KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider()); // Import a scope that contains all top-level namespaces that come from dependencies // This makes the namespaces visible at all, does not import themselves - scope.importScope(rootNs.getMemberScope()); - - scope.changeLockLevel(WritableScope.LockLevel.READING); + PackageViewDescriptor rootPackage = moduleDescriptor.getPackage(FqName.ROOT); + assert rootPackage != null : "Coulnd't find root package for " + moduleDescriptor; // dummy builder is used because "root" is module descriptor, // namespaces added to module explicitly in - doProcess(scope, new NamespaceLikeBuilderDummy(), files); + doProcess(rootPackage.getMemberScope(), new NamespaceLikeBuilderDummy(), files); } @@ -261,6 +253,10 @@ public class TopDownAnalyzer { } + @NotNull + public MutablePackageFragmentProvider getPackageFragmentProvider() { + return packageFragmentProvider; + } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java index 1f675219d57..ef280f817b3 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java @@ -28,10 +28,7 @@ import org.jetbrains.jet.lang.descriptors.impl.*; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.name.SpecialNames; -import org.jetbrains.jet.lang.resolve.scopes.JetScope; -import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler; -import org.jetbrains.jet.lang.resolve.scopes.WritableScope; -import org.jetbrains.jet.lang.resolve.scopes.WriteThroughScope; +import org.jetbrains.jet.lang.resolve.scopes.*; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.SubstitutionUtils; import org.jetbrains.jet.lang.types.TypeConstructor; @@ -43,8 +40,7 @@ import javax.inject.Inject; import java.util.*; import static org.jetbrains.jet.lang.diagnostics.Errors.*; -import static org.jetbrains.jet.lang.resolve.BindingContext.FQNAME_TO_CLASS_DESCRIPTOR; -import static org.jetbrains.jet.lang.resolve.BindingContext.TYPE; +import static org.jetbrains.jet.lang.resolve.BindingContext.*; import static org.jetbrains.jet.lang.resolve.DescriptorUtils.isEnumEntry; import static org.jetbrains.jet.lang.resolve.DescriptorUtils.isObject; import static org.jetbrains.jet.lang.resolve.ModifiersChecker.getDefaultClassVisibility; @@ -120,11 +116,11 @@ public class TypeHierarchyResolver { ((MutableClassDescriptorLite) descriptorForDeferredResolve).getBuilder(), declarationContainer.getDeclarations())); } - else if (descriptorForDeferredResolve instanceof NamespaceDescriptorImpl) { + else if (descriptorForDeferredResolve instanceof MutablePackageFragmentDescriptor) { forDeferredResolve.addAll( collectNamespacesAndClassifiers( scope, - ((NamespaceDescriptorImpl) descriptorForDeferredResolve).getBuilder(), + ((MutablePackageFragmentDescriptor) descriptorForDeferredResolve).getBuilder(), declarationContainer.getDeclarations())); } else { @@ -133,7 +129,7 @@ public class TypeHierarchyResolver { } } - importsResolver.processTypeImports(outerScope); + importsResolver.processTypeImports(); createTypeConstructors(); // create type constructors for classes and generic parameters, supertypes are not filled in resolveTypesInClassHeaders(); // Generic bounds and types in supertype lists (no expressions or constructor resolution) @@ -454,20 +450,22 @@ public class TypeHierarchyResolver { @Override public void visitJetFile(@NotNull JetFile file) { - NamespaceDescriptorImpl namespaceDescriptor = namespaceFactory.createNamespaceDescriptorPathIfNeeded( - file, outerScope, RedeclarationHandler.DO_NOTHING); - context.getNamespaceDescriptors().put(file, namespaceDescriptor); + MutablePackageFragmentDescriptor packageFragment = + namespaceFactory.createPackageFragmentIfNeeded(file, RedeclarationHandler.DO_NOTHING); + context.getPackageFragments().put(file, packageFragment); - WriteThroughScope namespaceScope = new WriteThroughScope(outerScope, namespaceDescriptor.getMemberScope(), - new TraceBasedRedeclarationHandler(trace), "namespace in file " + file.getName()); - namespaceScope.changeLockLevel(WritableScope.LockLevel.BOTH); - context.getNamespaceScopes().put(file, namespaceScope); + PackageViewDescriptor packageView = packageFragment.getContainingDeclaration().getPackage(packageFragment.getFqName()); + ChainedScope rootPlusPackageScope = new ChainedScope(packageView, packageView.getMemberScope(), outerScope); + WriteThroughScope packageScope = new WriteThroughScope(rootPlusPackageScope, packageFragment.getMemberScope(), + new TraceBasedRedeclarationHandler(trace), "package in file " + file.getName()); + packageScope.changeLockLevel(WritableScope.LockLevel.BOTH); + context.getNamespaceScopes().put(file, packageScope); if (file.isScript()) { - scriptHeaderResolver.processScriptHierarchy(file.getScript(), namespaceScope); + scriptHeaderResolver.processScriptHierarchy(file.getScript(), packageScope); } - prepareForDeferredCall(namespaceScope, namespaceDescriptor, file); + prepareForDeferredCall(packageScope, packageFragment, file); } @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallExpressionResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallExpressionResolver.java index 167bc922f65..cc20ed001d5 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallExpressionResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallExpressionResolver.java @@ -169,7 +169,7 @@ public class CallExpressionResolver { scopes.add(getStaticNestedClassesScope(classDescriptor)); Name referencedName = expression.getReferencedNameAsName(); - NamespaceDescriptor namespace = context.scope.getNamespace(referencedName); + PackageViewDescriptor namespace = context.scope.getPackage(referencedName); if (namespace != null) { //for enums loaded from java binaries scopes.add(namespace.getMemberScope()); @@ -200,7 +200,7 @@ public class CallExpressionResolver { @Nullable private NamespaceType lookupNamespaceType(@NotNull JetSimpleNameExpression expression, @NotNull ResolutionContext context) { Name name = expression.getReferencedNameAsName(); - NamespaceDescriptor namespace = context.scope.getNamespace(name); + PackageViewDescriptor namespace = context.scope.getPackage(name); if (namespace == null) { return null; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/extension/InlineAnalyzerExtension.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/extension/InlineAnalyzerExtension.java index aa2217fcce6..6e70213710e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/extension/InlineAnalyzerExtension.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/extension/InlineAnalyzerExtension.java @@ -99,7 +99,7 @@ public class InlineAnalyzerExtension implements FunctionAnalyzerExtension.Analyz return; } - if (functionDescriptor.getContainingDeclaration() instanceof NamespaceDescriptor) { + if (functionDescriptor.getContainingDeclaration() instanceof PackageFragmentDescriptor) { return; } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/KotlinCodeAnalyzer.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/KotlinCodeAnalyzer.java index 859e378d709..e8ff7625ff1 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/KotlinCodeAnalyzer.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/KotlinCodeAnalyzer.java @@ -17,22 +17,15 @@ package org.jetbrains.jet.lang.resolve.lazy; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; -import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.psi.JetClassOrObject; import org.jetbrains.jet.lang.psi.JetDeclaration; import org.jetbrains.jet.lang.resolve.BindingContext; -import org.jetbrains.jet.lang.resolve.name.FqName; -import org.jetbrains.jet.lang.resolve.name.Name; public interface KotlinCodeAnalyzer { - ModuleDescriptor getRootModuleDescriptor(); - - @Nullable - NamespaceDescriptor getPackageDescriptorByFqName(FqName fqName); + ModuleDescriptor getModuleDescriptor(); @NotNull ClassDescriptor getClassDescriptor(@NotNull JetClassOrObject classOrObject); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyImportScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyImportScope.java index 44636763552..a5bcc6ae95a 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyImportScope.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyImportScope.java @@ -44,7 +44,7 @@ import static org.jetbrains.jet.lang.resolve.QualifiedExpressionResolver.LookupM public class LazyImportScope implements JetScope { private final ResolveSession resolveSession; - private final NamespaceDescriptor packageDescriptor; + private final PackageViewDescriptor packageDescriptor; private final ImportsProvider importsProvider; private final JetScope rootScope; private final BindingTrace traceForImportResolve; @@ -99,7 +99,7 @@ public class LazyImportScope implements JetScope { packageDescriptor.getMemberScope(), importer, traceForImportResolve, - resolveSession.getRootModuleDescriptor(), + resolveSession.getModuleDescriptor(), mode); } finally { @@ -120,7 +120,7 @@ public class LazyImportScope implements JetScope { public LazyImportScope( @NotNull ResolveSession resolveSession, - @NotNull NamespaceDescriptor packageDescriptor, + @NotNull PackageViewDescriptor packageDescriptor, @NotNull List imports, @NotNull BindingTrace traceForImportResolve, @NotNull String debugName @@ -138,16 +138,16 @@ public class LazyImportScope implements JetScope { } }); - NamespaceDescriptor rootPackageDescriptor = resolveSession.getPackageDescriptorByFqName(FqName.ROOT); - if (rootPackageDescriptor == null) { + PackageViewDescriptor rootPackage = resolveSession.getModuleDescriptor().getPackage(FqName.ROOT); + if (rootPackage == null) { throw new IllegalStateException("Root package not found"); } - rootScope = rootPackageDescriptor.getMemberScope(); + rootScope = rootPackage.getMemberScope(); } public static LazyImportScope createImportScopeForFile( @NotNull ResolveSession resolveSession, - @NotNull NamespaceDescriptor packageDescriptor, + @NotNull PackageViewDescriptor packageDescriptor, @NotNull JetFile jetFile, @NotNull BindingTrace traceForImportResolve, @NotNull String debugName @@ -246,8 +246,8 @@ public class LazyImportScope implements JetScope { @Nullable @Override - public NamespaceDescriptor getNamespace(@NotNull Name name) { - return selectFirstFromImports(name, LookupMode.ONLY_CLASSES, JetScopeSelectorUtil.NAMESPACE_SCOPE_SELECTOR); + public PackageViewDescriptor getPackage(@NotNull Name name) { + return selectFirstFromImports(name, LookupMode.ONLY_CLASSES, JetScopeSelectorUtil.PACKAGE_SCOPE_SELECTOR); } @NotNull diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java index ed82050c784..b068aeb2892 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java @@ -18,16 +18,17 @@ package org.jetbrains.jet.lang.resolve.lazy; import com.google.common.base.Predicate; import com.google.common.base.Predicates; +import com.google.common.collect.Lists; import com.intellij.openapi.project.Project; import com.intellij.psi.PsiElement; import com.intellij.psi.util.PsiTreeUtil; import com.intellij.util.Function; +import com.intellij.util.containers.ContainerUtil; import jet.Function0; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.di.InjectorForLazyResolve; import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.descriptors.impl.DeclarationDescriptorVisitorEmptyBodies; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingTrace; @@ -43,8 +44,10 @@ import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.name.SpecialNames; import org.jetbrains.jet.lang.resolve.scopes.JetScope; +import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; +import org.jetbrains.jet.storage.MemoizedFunctionToNullable; -import java.util.List; +import java.util.*; import static org.jetbrains.jet.lang.resolve.lazy.ResolveSessionUtils.safeNameForLazyResolve; @@ -60,7 +63,6 @@ public class ResolveSession implements KotlinCodeAnalyzer { private final LazyResolveStorageManager storageManager; private final ModuleDescriptor module; - private final LazyPackageDescriptor rootPackage; private final BindingTrace trace; private final DeclarationProviderFactory declarationProviderFactory; @@ -72,6 +74,9 @@ public class ResolveSession implements KotlinCodeAnalyzer { private final Function classifierAliases; + private final MemoizedFunctionToNullable packages; + private final PackageFragmentProvider packageFragmentProvider; + public ResolveSession( @NotNull Project project, @NotNull LazyResolveStorageManager storageManager, @@ -117,10 +122,54 @@ public class ResolveSession implements KotlinCodeAnalyzer { this.module = rootDescriptor; PackageMemberDeclarationProvider provider = declarationProviderFactory.getPackageMemberDeclarationProvider(FqName.ROOT); assert provider != null : "No declaration provider for root package in " + rootDescriptor; - this.rootPackage = new LazyPackageDescriptor(rootDescriptor, FqNameUnsafe.ROOT_NAME, this, provider); - rootDescriptor.setRootNamespace(rootPackage); + + this.packages = storageManager.createMemoizedFunctionWithNullableValues(new MemoizedFunctionToNullable() { + @Nullable + @Override + public LazyPackageDescriptor invoke(FqName fqName) { + return createPackage(fqName); + } + }); this.declarationProviderFactory = declarationProviderFactory; + + rootDescriptor.addFragmentProvider(KotlinBuiltIns.getInstance().getBuiltInsModule().getPackageFragmentProvider()); + + this.packageFragmentProvider = new PackageFragmentProvider() { + @NotNull + @Override + public List getPackageFragments(@NotNull FqName fqName) { + return ContainerUtil.createMaybeSingletonList(getPackageFragment(fqName)); + } + + @NotNull + @Override + public Collection getSubPackagesOf(@NotNull FqName fqName) { + LazyPackageDescriptor packageDescriptor = getPackageFragment(fqName); + if (packageDescriptor == null) { + return Collections.emptyList(); + } + return packageDescriptor.getDeclarationProvider().getAllDeclaredPackages(); + } + }; + rootDescriptor.addFragmentProvider(packageFragmentProvider); + } + + @Nullable + public LazyPackageDescriptor getPackageFragment(@NotNull FqName fqName) { + return packages.invoke(fqName); + } + + @Nullable + private LazyPackageDescriptor createPackage(FqName fqName) { + if (!fqName.isRoot() && getPackageFragment(fqName.parent()) == null) { + return null; + } + PackageMemberDeclarationProvider provider = declarationProviderFactory.getPackageMemberDeclarationProvider(fqName); + if (provider == null) { + return null; + } + return new LazyPackageDescriptor(module, fqName, this, provider); } @NotNull @@ -133,7 +182,7 @@ public class ResolveSession implements KotlinCodeAnalyzer { } @Override - public ModuleDescriptor getRootModuleDescriptor() { + public ModuleDescriptor getModuleDescriptor() { return module; } @@ -142,22 +191,6 @@ public class ResolveSession implements KotlinCodeAnalyzer { return storageManager; } - @Override - @Nullable - public NamespaceDescriptor getPackageDescriptorByFqName(FqName fqName) { - if (fqName.isRoot()) { - return rootPackage; - } - List names = fqName.pathSegments(); - NamespaceDescriptor current = rootPackage.getMemberScope().getNamespace(names.get(0)); - if (current == null) return null; - for (Name name : names.subList(1, names.size())) { - current = current.getMemberScope().getNamespace(name); - if (current == null) return null; - } - return current; - } - @Override @NotNull public ClassDescriptor getClassDescriptor(@NotNull JetClassOrObject classOrObject) { @@ -343,45 +376,29 @@ public class ResolveSession implements KotlinCodeAnalyzer { return actualName; } + @NotNull + private List getAllPackages() { + return collectAllPackages(Lists.newArrayList(), getPackageFragment(FqName.ROOT)); + } + + @NotNull + private List collectAllPackages( + @NotNull List result, + @NotNull LazyPackageDescriptor current + ) { + result.add(current); + for (FqName subPackage : packageFragmentProvider.getSubPackagesOf(current.getFqName())) { + LazyPackageDescriptor fragment = getPackageFragment(subPackage); + assert fragment != null : "Couldn't find fragment for " + subPackage; + collectAllPackages(result, fragment); + } + return result; + } + @Override public void forceResolveAll() { - rootPackage.acceptVoid(new DeclarationDescriptorVisitorEmptyBodies() { - - @Override - public Void visitTypeParameterDescriptor(TypeParameterDescriptor descriptor, Void data) { - ForceResolveUtil.forceResolveAllContents(descriptor); - return null; - } - - @Override - public Void visitNamespaceDescriptor(NamespaceDescriptor descriptor, Void data) { - ForceResolveUtil.forceResolveAllContents(descriptor); - return null; - } - - @Override - public Void visitPackageViewDescriptor(PackageViewDescriptor descriptor, Void data) { - ForceResolveUtil.forceResolveAllContents(descriptor); - return super.visitPackageViewDescriptor(descriptor, data); - } - - @Override - public Void visitClassDescriptor(ClassDescriptor descriptor, Void data) { - ForceResolveUtil.forceResolveAllContents(descriptor); - return null; - } - - @Override - public Void visitModuleDeclaration(ModuleDescriptor descriptor, Void data) { - ForceResolveUtil.forceResolveAllContents(descriptor); - return null; - } - - @Override - public Void visitScriptDescriptor(ScriptDescriptor scriptDescriptor, Void data) { - ForceResolveUtil.forceResolveAllContents(scriptDescriptor); - return null; - } - }); + for (LazyPackageDescriptor lazyPackage : getAllPackages()) { + ForceResolveUtil.forceResolveAllContents(lazyPackage); + } } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSessionUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSessionUtils.java index 55e5cd18442..99c18cdf092 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSessionUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSessionUtils.java @@ -21,7 +21,7 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor; -import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor; import org.jetbrains.jet.lang.psi.JetNamed; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; @@ -63,7 +63,7 @@ public class ResolveSessionUtils { FqName packageFqName = fqName.parent(); while (true) { - NamespaceDescriptor packageDescriptor = analyzer.getPackageDescriptorByFqName(packageFqName); + PackageViewDescriptor packageDescriptor = analyzer.getModuleDescriptor().getPackage(packageFqName); if (packageDescriptor != null) { FqName classInPackagePath = new FqName(QualifiedNamesUtil.tail(packageFqName, fqName)); Collection descriptors = getClassOrObjectDescriptorsByFqName(packageDescriptor, classInPackagePath, @@ -84,7 +84,7 @@ public class ResolveSessionUtils { @NotNull private static Collection getClassOrObjectDescriptorsByFqName( - @NotNull NamespaceDescriptor packageDescriptor, + @NotNull PackageViewDescriptor packageDescriptor, @NotNull FqName path, boolean includeObjectDeclarations ) { diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java index 496f872c88b..50ebb73cbb6 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java @@ -22,7 +22,7 @@ import com.intellij.psi.util.PsiTreeUtil; import jet.Function0; import jet.Function1; import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor; import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.ImportPath; import org.jetbrains.jet.lang.resolve.TemporaryBindingTrace; @@ -67,12 +67,12 @@ public class ScopeProvider { } private JetScope createFileScope(JetFile file) { - NamespaceDescriptor rootPackageDescriptor = resolveSession.getPackageDescriptorByFqName(FqName.ROOT); + PackageViewDescriptor rootPackageDescriptor = resolveSession.getModuleDescriptor().getPackage(FqName.ROOT); if (rootPackageDescriptor == null) { throw new IllegalStateException("Root package not found"); } - NamespaceDescriptor packageDescriptor = getFilePackageDescriptor(file); + PackageViewDescriptor packageDescriptor = getFilePackageDescriptor(file); JetScope importsScope = LazyImportScope.createImportScopeForFile( resolveSession, @@ -81,7 +81,7 @@ public class ScopeProvider { resolveSession.getTrace(), "Lazy Imports Scope for file " + file.getName()); - return new ChainedScope(packageDescriptor, + return new ChainedScope(resolveSession.getPackageFragment(JetPsiUtil.getFQName(file)), "File scope: " + file.getName(), packageDescriptor.getMemberScope(), rootPackageDescriptor.getMemberScope(), @@ -90,33 +90,33 @@ public class ScopeProvider { } private JetScope createScopeWithDefaultImports() { - NamespaceDescriptor rootPackageDescriptor = resolveSession.getPackageDescriptorByFqName(FqName.ROOT); - if (rootPackageDescriptor == null) { + PackageViewDescriptor rootPackage = resolveSession.getModuleDescriptor().getPackage(FqName.ROOT); + if (rootPackage == null) { throw new IllegalStateException("Root package not found"); } JetImportsFactory importsFactory = resolveSession.getInjector().getJetImportsFactory(); - List defaultImports = resolveSession.getRootModuleDescriptor().getDefaultImports(); + List defaultImports = resolveSession.getModuleDescriptor().getDefaultImports(); Collection defaultImportDirectives = importsFactory.createImportDirectives(defaultImports); return new LazyImportScope( resolveSession, - rootPackageDescriptor, + rootPackage, Lists.reverse(Lists.newArrayList(defaultImportDirectives)), TemporaryBindingTrace.create(resolveSession.getTrace(), "Transient trace for default imports lazy resolve"), "Lazy default imports scope"); } @NotNull - private NamespaceDescriptor getFilePackageDescriptor(JetFile file) { + private PackageViewDescriptor getFilePackageDescriptor(JetFile file) { JetNamespaceHeader header = file.getNamespaceHeader(); if (header == null) { throw new IllegalArgumentException("Scripts are not supported: " + file.getName()); } FqName fqName = new FqName(header.getQualifiedName()); - NamespaceDescriptor packageDescriptor = resolveSession.getPackageDescriptorByFqName(fqName); + PackageViewDescriptor packageDescriptor = resolveSession.getModuleDescriptor().getPackage(fqName); if (packageDescriptor == null) { throw new IllegalStateException("Package not found: " + fqName + " maybe the file is not in scope of this resolve session: " + file.getName()); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassMemberScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassMemberScope.java index 9b870ba4435..021560fde94 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassMemberScope.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassMemberScope.java @@ -329,8 +329,9 @@ public class LazyClassMemberScope extends AbstractLazyMemberScopeemptyList(), name); + super(Collections.emptyList(), fqName.shortNameOrSpecial()); + this.module = module; + this.fqName = fqName; + this.declarationProvider = declarationProvider; - WritableScopeImpl scope = new WritableScopeImpl(JetScope.EMPTY, this, RedeclarationHandler.DO_NOTHING, "Package scope"); - resolveSession.getRootModuleDescriptor().getModuleConfiguration().extendNamespaceScope(this, scope); - scope.changeLockLevel(WritableScope.LockLevel.READING); - - this.lazyScope = new LazyPackageMemberScope(resolveSession, declarationProvider, this); - - this.memberScope = new ChainedScope(this, "Lazy package members scope: " + name, lazyScope, scope); - - NavigatablePsiElement declaration = Iterables.getFirst(declarationProvider.getPackageDeclarations(getFqName()), null); - if (declaration != null) { - resolveSession.getTrace().record(BindingContext.NAMESPACE, declaration, this); - } + this.memberScope = new LazyPackageMemberScope(resolveSession, declarationProvider, this); } @NotNull @@ -69,17 +59,34 @@ public class LazyPackageDescriptor extends AbstractNamespaceDescriptorImpl imple @NotNull @Override - public FqName getFqName() { - return DescriptorUtils.getFQName(this).toSafe(); + public ModuleDescriptor getContainingDeclaration() { + return module; + } + + @Nullable + @Override + public DeclarationDescriptor substitute(@NotNull TypeSubstitutor substitutor) { + return this; } @Override - public void addNamespace(@NotNull NamespaceDescriptor namespaceDescriptor) { - throw new UnsupportedOperationException(); // TODO + public R accept(DeclarationDescriptorVisitor visitor, D data) { + return visitor.visitPackageFragmentDescriptor(this, data); + } + + @NotNull + @Override + public FqName getFqName() { + return fqName; } @Override public void forceResolveAllContents() { - ForceResolveUtil.forceResolveAllContents(lazyScope); + ForceResolveUtil.forceResolveAllContents(memberScope); + } + + @NotNull + public PackageMemberDeclarationProvider getDeclarationProvider() { + return declarationProvider; } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyPackageMemberScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyPackageMemberScope.java index 3254c5b1bd4..8fe66f04b85 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyPackageMemberScope.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyPackageMemberScope.java @@ -16,7 +16,6 @@ package org.jetbrains.jet.lang.resolve.lazy.descriptors; -import jet.Function1; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; @@ -28,43 +27,22 @@ import org.jetbrains.jet.lang.resolve.lazy.declarations.PackageMemberDeclaration import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; -import org.jetbrains.jet.storage.MemoizedFunctionToNullable; import java.util.Collection; import java.util.Set; -public class LazyPackageMemberScope extends AbstractLazyMemberScope { - - private final MemoizedFunctionToNullable packageDescriptors; +public class LazyPackageMemberScope extends AbstractLazyMemberScope { public LazyPackageMemberScope(@NotNull ResolveSession resolveSession, @NotNull PackageMemberDeclarationProvider declarationProvider, - @NotNull NamespaceDescriptor thisPackage) { + @NotNull PackageFragmentDescriptor thisPackage) { super(resolveSession, declarationProvider, thisPackage); - - this.packageDescriptors = resolveSession.getStorageManager().createMemoizedFunctionWithNullableValues( - new Function1() { - @Override - public NamespaceDescriptor invoke(Name name) { - return createPackageDescriptor(name); - } - }); - } - - @Override - public NamespaceDescriptor getNamespace(@NotNull Name name) { - return packageDescriptors.invoke(name); } @Nullable - public NamespaceDescriptor createPackageDescriptor(@NotNull Name name) { - if (!declarationProvider.isPackageDeclared(name)) return null; - - PackageMemberDeclarationProvider packageMemberDeclarationProvider = resolveSession.getDeclarationProviderFactory().getPackageMemberDeclarationProvider( - DescriptorUtils.getFQName(thisDescriptor).child(name).toSafe()); - assert packageMemberDeclarationProvider != null : "Package is declared, but declaration provider is not found: " + name; - - return new LazyPackageDescriptor(thisDescriptor, name, resolveSession, packageMemberDeclarationProvider); + @Override + public PackageViewDescriptor getPackage(@NotNull Name name) { + return null; } @Override @@ -97,9 +75,6 @@ public class LazyPackageMemberScope extends AbstractLazyMemberScope result) { - for (FqName packageFqName : declarationProvider.getAllDeclaredPackages()) { - result.add(getNamespace(packageFqName.shortName())); - } } @Override diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeSelectorUtil.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeSelectorUtil.java index 664dd150d33..9d23355b7a4 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeSelectorUtil.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeSelectorUtil.java @@ -75,12 +75,12 @@ public class JetScopeSelectorUtil { } }; - public static final ScopeByNameSelector NAMESPACE_SCOPE_SELECTOR = - new ScopeByNameSelector() { + public static final ScopeByNameSelector PACKAGE_SCOPE_SELECTOR = + new ScopeByNameSelector() { @Nullable @Override - public NamespaceDescriptor get(@NotNull JetScope scope, @NotNull Name name) { - return scope.getNamespace(name); + public PackageViewDescriptor get(@NotNull JetScope scope, @NotNull Name name) { + return scope.getPackage(name); } }; diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WriteThroughScope.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WriteThroughScope.java index b7e36cf91ea..0966e210ede 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WriteThroughScope.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WriteThroughScope.java @@ -30,6 +30,11 @@ import org.jetbrains.jet.utils.Printer; import java.util.Collection; import java.util.Set; +// Reads from: +// 1. Worker (a.k.a outer) +// 2. Imports + +// Writes to: writable worker public class WriteThroughScope extends WritableScopeWithImports { private final WritableScope writableWorker; private Collection allDescriptors; @@ -62,13 +67,8 @@ public class WriteThroughScope extends WritableScopeWithImports { checkMayRead(); Set result = Sets.newLinkedHashSet(); - - result.addAll(writableWorker.getFunctions(name)); - result.addAll(getWorkerScope().getFunctions(name)); - result.addAll(super.getFunctions(name)); // Imports - return result; } @@ -78,7 +78,6 @@ public class WriteThroughScope extends WritableScopeWithImports { checkMayRead(); Set properties = Sets.newLinkedHashSet(); - properties.addAll(writableWorker.getProperties(name)); properties.addAll(getWorkerScope().getProperties(name)); properties.addAll(super.getProperties(name)); //imports return properties; @@ -89,10 +88,7 @@ public class WriteThroughScope extends WritableScopeWithImports { public VariableDescriptor getLocalVariable(@NotNull Name name) { checkMayRead(); - VariableDescriptor variable = writableWorker.getLocalVariable(name); - if (variable != null) return variable; - - variable = getWorkerScope().getLocalVariable(name); + VariableDescriptor variable = getWorkerScope().getLocalVariable(name); if (variable != null) return variable; return super.getLocalVariable(name); // Imports @@ -100,16 +96,13 @@ public class WriteThroughScope extends WritableScopeWithImports { @Override @Nullable - public NamespaceDescriptor getNamespace(@NotNull Name name) { + public PackageViewDescriptor getPackage(@NotNull Name name) { checkMayRead(); - NamespaceDescriptor namespace = writableWorker.getNamespace(name); - if (namespace != null) return namespace; + PackageViewDescriptor aPackage = getWorkerScope().getPackage(name); + if (aPackage != null) return aPackage; - namespace = getWorkerScope().getNamespace(name); - if (namespace != null) return namespace; - - return super.getNamespace(name); // Imports + return super.getPackage(name); // Imports } @Override @@ -117,10 +110,7 @@ public class WriteThroughScope extends WritableScopeWithImports { public ClassifierDescriptor getClassifier(@NotNull Name name) { checkMayRead(); - ClassifierDescriptor classifier = writableWorker.getClassifier(name); - if (classifier != null) return classifier; - - classifier = getWorkerScope().getClassifier(name); + ClassifierDescriptor classifier = getWorkerScope().getClassifier(name); if (classifier != null) return classifier; return super.getClassifier(name); // Imports @@ -130,7 +120,7 @@ public class WriteThroughScope extends WritableScopeWithImports { public void addLabeledDeclaration(@NotNull DeclarationDescriptor descriptor) { checkMayWrite(); - writableWorker.addLabeledDeclaration(descriptor); // TODO : review + writableWorker.addLabeledDeclaration(descriptor); } @Override @@ -176,10 +166,10 @@ public class WriteThroughScope extends WritableScopeWithImports { } @Override - public void addNamespaceAlias(@NotNull Name name, @NotNull NamespaceDescriptor namespaceDescriptor) { + public void addPackageAlias(@NotNull Name name, @NotNull PackageViewDescriptor packageView) { checkMayWrite(); - writableWorker.addNamespaceAlias(name, namespaceDescriptor); + writableWorker.addPackageAlias(name, packageView); } @Override @@ -221,7 +211,7 @@ public class WriteThroughScope extends WritableScopeWithImports { public void importScope(@NotNull JetScope imported) { checkMayWrite(); - super.importScope(imported); // + super.importScope(imported); } @Override @@ -238,7 +228,6 @@ public class WriteThroughScope extends WritableScopeWithImports { if (allDescriptors == null) { allDescriptors = Lists.newArrayList(); - allDescriptors.addAll(writableWorker.getAllDescriptors()); allDescriptors.addAll(getWorkerScope().getAllDescriptors()); for (JetScope imported : getImports()) { diff --git a/compiler/testData/builtin-classes.txt b/compiler/testData/builtin-classes.txt index 6c53bd95ae8..8847bcd860b 100644 --- a/compiler/testData/builtin-classes.txt +++ b/compiler/testData/builtin-classes.txt @@ -1,4 +1,4 @@ -package jet +package-fragment jet public fun arrayOfNulls(/*0*/ size: jet.Int): jet.Array public fun synchronized(/*0*/ lock: jet.Any, /*1*/ block: () -> R): R diff --git a/compiler/testData/recursiveProcessor/declarations.txt b/compiler/testData/recursiveProcessor/declarations.txt index 8a38634db0b..02a127febcb 100644 --- a/compiler/testData/recursiveProcessor/declarations.txt +++ b/compiler/testData/recursiveProcessor/declarations.txt @@ -64,7 +64,7 @@ innerTest.:PropertySetterDescriptor innerTest.func:SimpleFunctionDescriptor innerTest.prop:PropertyDescriptor innerTest.propVar:PropertyDescriptor -innerTest:NamespaceDescriptor +innerTest:PackageViewDescriptor prop.this:ReceiverParameterDescriptor prop.this:ReceiverParameterDescriptor -test:NamespaceDescriptor \ No newline at end of file +test:PackageViewDescriptor diff --git a/compiler/tests/org/jetbrains/jet/JetTestUtils.java b/compiler/tests/org/jetbrains/jet/JetTestUtils.java index b43c822dec8..fcb44406dbd 100644 --- a/compiler/tests/org/jetbrains/jet/JetTestUtils.java +++ b/compiler/tests/org/jetbrains/jet/JetTestUtils.java @@ -50,8 +50,7 @@ import org.jetbrains.jet.config.CompilerConfiguration; import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl; -import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; -import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorImpl; +import org.jetbrains.jet.lang.descriptors.impl.MutablePackageFragmentDescriptor; import org.jetbrains.jet.lang.diagnostics.Diagnostic; import org.jetbrains.jet.lang.diagnostics.Errors; import org.jetbrains.jet.lang.diagnostics.Severity; @@ -61,11 +60,8 @@ import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.resolve.*; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; import org.jetbrains.jet.lang.resolve.lazy.LazyResolveTestUtil; +import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; -import org.jetbrains.jet.lang.resolve.name.SpecialNames; -import org.jetbrains.jet.lang.resolve.scopes.JetScope; -import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler; -import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl; import org.jetbrains.jet.plugin.JetLanguage; import org.jetbrains.jet.test.InnerTestClasses; import org.jetbrains.jet.test.TestMetadata; @@ -711,14 +707,16 @@ public class JetTestUtils { } @NotNull - public static NamespaceDescriptorImpl createTestNamespace(@NotNull Name testPackageName) { - ModuleDescriptorImpl module = AnalyzerFacadeForJVM.createJavaModule(""); - NamespaceDescriptorImpl rootNamespace = - new NamespaceDescriptorImpl(module, Collections.emptyList(), SpecialNames.ROOT_NAMESPACE); - module.setRootNamespace(rootNamespace); - NamespaceDescriptorImpl test = new NamespaceDescriptorImpl(rootNamespace, Collections.emptyList(), testPackageName); - test.initialize(new WritableScopeImpl(JetScope.EMPTY, test, RedeclarationHandler.DO_NOTHING, "members of test namespace")); - return test; + public static MutablePackageFragmentDescriptor createTestPackageFragment(@NotNull Name testPackageName) { + return createTestPackageFragment(testPackageName, ""); + } + + @NotNull + public static MutablePackageFragmentDescriptor createTestPackageFragment(@NotNull Name testPackageName, @NotNull String moduleName) { + ModuleDescriptorImpl module = AnalyzerFacadeForJVM.createJavaModule(moduleName); + MutablePackageFragmentProvider provider = new MutablePackageFragmentProvider(module); + module.addFragmentProvider(provider); + return provider.getOrCreateFragment(FqName.topLevel(testPackageName)); } @NotNull diff --git a/compiler/tests/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorSerializationTest.java b/compiler/tests/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorSerializationTest.java index b740940c169..116b6bfb9e4 100644 --- a/compiler/tests/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorSerializationTest.java +++ b/compiler/tests/org/jetbrains/jet/descriptors/serialization/AbstractDescriptorSerializationTest.java @@ -24,7 +24,7 @@ import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver; import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorImpl; +import org.jetbrains.jet.lang.descriptors.impl.MutablePackageFragmentDescriptor; import org.jetbrains.jet.lang.resolve.BindingTraceContext; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; @@ -61,22 +61,23 @@ public abstract class AbstractDescriptorSerializationTest extends KotlinTestWith JetTestUtils.createFile(ktFile.getName(), FileUtil.loadFile(ktFile), getProject()) ), getEnvironment()); - NamespaceDescriptor testNamespace = moduleDescriptor.getNamespace(FqName.topLevel(TEST_PACKAGE_NAME)); - assert testNamespace != null; + PackageFragmentDescriptor testPackage = moduleDescriptor.getPackageFragmentProvider() + .getPackageFragments(FqName.topLevel(TEST_PACKAGE_NAME)).get(0); // TODO 2 hack + assert testPackage != null; InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(getProject(), new BindingTraceContext()); JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver(); - NamespaceDescriptor deserialized = serializeAndDeserialize(javaDescriptorResolver, testNamespace); + PackageFragmentDescriptor deserialized = serializeAndDeserialize(javaDescriptorResolver, testPackage); RecursiveDescriptorComparator - .validateAndCompareDescriptors(testNamespace, deserialized, RecursiveDescriptorComparator.RECURSIVE, null); + .validateAndCompareDescriptors(testPackage, deserialized, RecursiveDescriptorComparator.RECURSIVE, null); } @NotNull - private static NamespaceDescriptor serializeAndDeserialize( + private static PackageFragmentDescriptor serializeAndDeserialize( @NotNull JavaDescriptorResolver javaDescriptorResolver, - @NotNull NamespaceDescriptor testPackage + @NotNull PackageFragmentDescriptor testPackage ) { List classesAndObjects = getAllClassesAndObjects(testPackage.getMemberScope()); @@ -91,36 +92,36 @@ public abstract class AbstractDescriptorSerializationTest extends KotlinTestWith classDataMap.put(key, value); } - NamespaceDescriptorImpl namespace = JetTestUtils.createTestNamespace(TEST_PACKAGE_NAME); + MutablePackageFragmentDescriptor packageFragment = JetTestUtils.createTestPackageFragment(TEST_PACKAGE_NAME, ""); - DescriptorFinder descriptorFinder = new DescriptorFinderFromClassDataOrJava(javaDescriptorResolver, namespace, classDataMap); + DescriptorFinder descriptorFinder = new DescriptorFinderFromClassDataOrJava(javaDescriptorResolver, packageFragment, classDataMap); for (ClassDescriptor classDescriptor : classesAndObjects) { ClassId classId = getClassId(classDescriptor); ClassDescriptor descriptor = descriptorFinder.findClass(classId); assert descriptor != null : "Class not loaded: " + classId; - namespace.getMemberScope().addClassifierDescriptor(descriptor); + packageFragment.getMemberScope().addClassifierDescriptor(descriptor); } PackageData data = PackageData.read(serializedPackage, JavaProtoBufUtil.getExtensionRegistry()); DescriptorDeserializer deserializer = DescriptorDeserializer - .create(new LockBasedStorageManager(), namespace, data.getNameResolver(), descriptorFinder, UNSUPPORTED); + .create(new LockBasedStorageManager(), packageFragment, data.getNameResolver(), descriptorFinder, UNSUPPORTED); for (ProtoBuf.Callable proto : data.getPackageProto().getMemberList()) { CallableMemberDescriptor descriptor = deserializer.loadCallable(proto); if (descriptor instanceof FunctionDescriptor) { - namespace.getMemberScope().addFunctionDescriptor((FunctionDescriptor) descriptor); + packageFragment.getMemberScope().addFunctionDescriptor((FunctionDescriptor) descriptor); } else if (descriptor instanceof PropertyDescriptor) { - namespace.getMemberScope().addPropertyDescriptor((PropertyDescriptor) descriptor); + packageFragment.getMemberScope().addPropertyDescriptor((PropertyDescriptor) descriptor); } else { throw new IllegalStateException("Unknown descriptor type: " + descriptor); } } - namespace.getMemberScope().changeLockLevel(WritableScope.LockLevel.READING); + packageFragment.getMemberScope().changeLockLevel(WritableScope.LockLevel.READING); - return namespace; + return packageFragment; } @NotNull @@ -135,9 +136,9 @@ public abstract class AbstractDescriptorSerializationTest extends KotlinTestWith } @NotNull - private static byte[] serializePackage(@NotNull NamespaceDescriptor descriptor) { + private static byte[] serializePackage(@NotNull PackageFragmentDescriptor descriptor) { DescriptorSerializer serializer = new DescriptorSerializer(); - ProtoBuf.Package proto = serializer.packageProto(descriptor).build(); + ProtoBuf.Package proto = serializer.packageProto(Collections.singleton(descriptor)).build(); PackageData data = new PackageData(createNameResolver(serializer.getNameTable()), proto); return data.toBytes(); } @@ -160,12 +161,12 @@ public abstract class AbstractDescriptorSerializationTest extends KotlinTestWith private static class DescriptorFinderFromClassDataOrJava extends AbstractDescriptorFinder { private final JavaDescriptorResolver javaDescriptorResolver; - private final NamespaceDescriptor packageForClasses; + private final PackageFragmentDescriptor packageForClasses; private final Map classDataMap; public DescriptorFinderFromClassDataOrJava( @NotNull JavaDescriptorResolver javaDescriptorResolver, - @NotNull NamespaceDescriptor packageForClasses, + @NotNull PackageFragmentDescriptor packageForClasses, @NotNull Map classDataMap ) { super(new LockBasedStorageManager(), UNSUPPORTED); @@ -189,7 +190,7 @@ public abstract class AbstractDescriptorSerializationTest extends KotlinTestWith @Nullable @Override - public NamespaceDescriptor findPackage(@NotNull FqName name) { + public PackageFragmentDescriptor findPackage(@NotNull FqName name) { assert DescriptorUtils.getFQName(packageForClasses).equals(name.toUnsafe()) : name + " : " + packageForClasses; return packageForClasses; } diff --git a/compiler/tests/org/jetbrains/jet/descriptors/serialization/BuiltinsDeserializationTest.java b/compiler/tests/org/jetbrains/jet/descriptors/serialization/BuiltinsDeserializationTest.java index 9bb19361b6b..7042e36826a 100644 --- a/compiler/tests/org/jetbrains/jet/descriptors/serialization/BuiltinsDeserializationTest.java +++ b/compiler/tests/org/jetbrains/jet/descriptors/serialization/BuiltinsDeserializationTest.java @@ -27,7 +27,7 @@ import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationDeserializer; import org.jetbrains.jet.jvm.compiler.ExpectedLoadErrorsUtil; import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorImpl; +import org.jetbrains.jet.lang.descriptors.impl.MutablePackageFragmentDescriptor; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.lazy.KotlinTestWithEnvironment; import org.jetbrains.jet.lang.resolve.name.FqName; @@ -52,7 +52,7 @@ public class BuiltinsDeserializationTest extends KotlinTestWithEnvironment { public void testBuiltIns() throws Exception { Collection allDescriptors = KotlinBuiltIns.getInstance().getBuiltInsScope().getAllDescriptors(); - NamespaceDescriptorImpl actualNamespace = getDeserializedDescriptorsAsNamespace(allDescriptors); + PackageFragmentDescriptor actualPackage = getDeserializedDescriptorsAsPackage(allDescriptors); RecursiveDescriptorComparator.Configuration configuration = RecursiveDescriptorComparator.RECURSIVE.withRenderer( new DescriptorRendererBuilder() @@ -65,26 +65,26 @@ public class BuiltinsDeserializationTest extends KotlinTestWithEnvironment { .build() ); RecursiveDescriptorComparator - .validateAndCompareDescriptors(KotlinBuiltIns.getInstance().getBuiltInsPackage(), actualNamespace, configuration, null); + .validateAndCompareDescriptors(KotlinBuiltIns.getInstance().getBuiltInsPackageFragment(), actualPackage, configuration, null); } - private static NamespaceDescriptorImpl getDeserializedDescriptorsAsNamespace(Collection allDescriptors) { + private static PackageFragmentDescriptor getDeserializedDescriptorsAsPackage(Collection allDescriptors) { DescriptorSerializer serializer = new DescriptorSerializer(); final Map classProtos = serializeClasses(serializer, allDescriptors); List callableProtos = serializeCallables(serializer, allDescriptors); - final NamespaceDescriptorImpl actualNamespace = JetTestUtils.createTestNamespace(KotlinBuiltIns.BUILT_INS_PACKAGE_NAME); + final MutablePackageFragmentDescriptor actualPackage = JetTestUtils.createTestPackageFragment(KotlinBuiltIns.BUILT_INS_PACKAGE_NAME); final NameResolver nameResolver = NameSerializationUtil.createNameResolver(serializer.getNameTable()); DescriptorFinder finder = new AbstractDescriptorFinder(new LockBasedStorageManager(), AnnotationDeserializer.UNSUPPORTED) { @NotNull @Override - public NamespaceDescriptor findPackage(@NotNull FqName fqName) { + public PackageFragmentDescriptor findPackage(@NotNull FqName fqName) { assert fqName.equals(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME) : "Unsupported package: " + fqName; - return actualNamespace; + return actualPackage; } @NotNull @@ -110,7 +110,7 @@ public class BuiltinsDeserializationTest extends KotlinTestWithEnvironment { case ENUM_CLASS: case ANNOTATION_CLASS: case OBJECT: - actualNamespace.getMemberScope().addClassifierDescriptor(classDescriptor); + actualPackage.getMemberScope().addClassifierDescriptor(classDescriptor); break; case ENUM_ENTRY: assert false : "Enum entry appears to be a top-level declaration: " + classDescriptor; @@ -125,10 +125,10 @@ public class BuiltinsDeserializationTest extends KotlinTestWithEnvironment { finder.findClass(classId); } - deserializeCallables(callableProtos, actualNamespace, nameResolver, finder); + deserializeCallables(callableProtos, actualPackage, nameResolver, finder); - actualNamespace.getMemberScope().changeLockLevel(WritableScope.LockLevel.READING); - return actualNamespace; + actualPackage.getMemberScope().changeLockLevel(WritableScope.LockLevel.READING); + return actualPackage; } private static Map serializeClasses( @@ -163,21 +163,21 @@ public class BuiltinsDeserializationTest extends KotlinTestWithEnvironment { private static void deserializeCallables( List callableProtos, - NamespaceDescriptorImpl actualNamespace, + MutablePackageFragmentDescriptor actualPackage, NameResolver nameResolver, DescriptorFinder descriptorFinder ) { DescriptorDeserializer descriptorDeserializer = - DescriptorDeserializer.create(new LockBasedStorageManager(), actualNamespace, nameResolver, descriptorFinder, AnnotationDeserializer.UNSUPPORTED); + DescriptorDeserializer.create(new LockBasedStorageManager(), actualPackage, nameResolver, descriptorFinder, AnnotationDeserializer.UNSUPPORTED); for (ProtoBuf.Callable callableProto : callableProtos) { CallableMemberDescriptor callableMemberDescriptor = descriptorDeserializer.loadCallable(callableProto); if (callableMemberDescriptor instanceof PropertyDescriptor) { PropertyDescriptor propertyDescriptor = (PropertyDescriptor) callableMemberDescriptor; - actualNamespace.getMemberScope().addPropertyDescriptor(propertyDescriptor); + actualPackage.getMemberScope().addPropertyDescriptor(propertyDescriptor); } else if (callableMemberDescriptor instanceof FunctionDescriptor) { FunctionDescriptor functionDescriptor = (FunctionDescriptor) callableMemberDescriptor; - actualNamespace.getMemberScope().addFunctionDescriptor(functionDescriptor); + actualPackage.getMemberScope().addFunctionDescriptor(functionDescriptor); } } } diff --git a/compiler/tests/org/jetbrains/jet/descriptors/serialization/ClassSerializationUtil.java b/compiler/tests/org/jetbrains/jet/descriptors/serialization/ClassSerializationUtil.java index 9d6651d9d9f..c32679a765a 100644 --- a/compiler/tests/org/jetbrains/jet/descriptors/serialization/ClassSerializationUtil.java +++ b/compiler/tests/org/jetbrains/jet/descriptors/serialization/ClassSerializationUtil.java @@ -19,7 +19,7 @@ package org.jetbrains.jet.descriptors.serialization; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor; import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import java.util.Collection; @@ -63,8 +63,8 @@ public class ClassSerializationUtil { @NotNull public static ClassId getClassId(@NotNull ClassDescriptor classDescriptor) { DeclarationDescriptor owner = classDescriptor.getContainingDeclaration(); - if (owner instanceof NamespaceDescriptor) { - return new ClassId(((NamespaceDescriptor) owner).getFqName(), FqNameUnsafe.topLevel(classDescriptor.getName())); + if (owner instanceof PackageFragmentDescriptor) { + return new ClassId(((PackageFragmentDescriptor) owner).getFqName(), FqNameUnsafe.topLevel(classDescriptor.getName())); } return getClassId((ClassDescriptor) owner).createNestedClassId(classDescriptor.getName()); } diff --git a/compiler/tests/org/jetbrains/jet/evaluate/AbstractEvaluateExpressionTest.kt b/compiler/tests/org/jetbrains/jet/evaluate/AbstractEvaluateExpressionTest.kt index 7000a416e20..4ad52daaa61 100644 --- a/compiler/tests/org/jetbrains/jet/evaluate/AbstractEvaluateExpressionTest.kt +++ b/compiler/tests/org/jetbrains/jet/evaluate/AbstractEvaluateExpressionTest.kt @@ -55,7 +55,7 @@ abstract class AbstractEvaluateExpressionTest: AbstractAnnotationDescriptorResol private fun doTest(path: String, getValueToTest: (JetProperty, BindingContext) -> String) { val myFile = File(path) val fileText = FileUtil.loadFile(myFile) - val namespaceDescriptor = getNamespaceDescriptor(fileText) + val packageView = getPackage(fileText) val propertiesForTest = getObjectsToTest(fileText) @@ -66,7 +66,7 @@ abstract class AbstractEvaluateExpressionTest: AbstractAnnotationDescriptorResol val expected = InTextDirectivesUtils.findStringWithPrefixes(fileText, expectedProperyPrefix) assertNotNull(expected, "Failed to find expected directive: $expectedProperyPrefix") - val property = AbstractAnnotationDescriptorResolveTest.getPropertyDescriptor(namespaceDescriptor, propertyName) + val property = AbstractAnnotationDescriptorResolveTest.getPropertyDescriptor(packageView, propertyName) val jetProperty = BindingContextUtils.descriptorToDeclaration(context!!, property) as JetProperty val testedObject = getValueToTest(jetProperty, context!!) diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadCompiledKotlinTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadCompiledKotlinTest.java index d165a23ca31..9cc3682d979 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadCompiledKotlinTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadCompiledKotlinTest.java @@ -22,8 +22,10 @@ import org.jetbrains.jet.ConfigurationKind; import org.jetbrains.jet.analyzer.AnalyzeExhaust; import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedClassDescriptor; import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedPackageMemberScope; -import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.resolve.BindingContext; +import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor; +import org.jetbrains.jet.lang.descriptors.ClassDescriptor; +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; +import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.test.TestCaseWithTmpdir; @@ -55,43 +57,43 @@ public abstract class AbstractLoadCompiledKotlinTest extends TestCaseWithTmpdir AnalyzeExhaust exhaust = compileKotlinToDirAndGetAnalyzeExhaust(ktFile, tmpdir, getTestRootDisposable(), ConfigurationKind.JDK_ONLY); - NamespaceDescriptor namespaceFromSource = exhaust.getBindingContext().get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, - TEST_PACKAGE_FQNAME); - assert namespaceFromSource != null; - Assert.assertEquals("test", namespaceFromSource.getName().asString()); + PackageViewDescriptor packageFromSource = exhaust.getModuleDescriptor().getPackage(TEST_PACKAGE_FQNAME); + assert packageFromSource != null; + Assert.assertEquals("test", packageFromSource.getName().asString()); - NamespaceDescriptor namespaceFromClass = LoadDescriptorUtil.loadTestNamespaceAndBindingContextFromJavaRoot( + PackageViewDescriptor packageFromBinary = LoadDescriptorUtil.loadTestPackageAndBindingContextFromJavaRoot( tmpdir, getTestRootDisposable(), ConfigurationKind.JDK_ONLY).first; - checkUsageOfDeserializedScope(namespaceFromClass); + checkUsageOfDeserializedScope(packageFromBinary); - for (DeclarationDescriptor descriptor : namespaceFromClass.getMemberScope().getAllDescriptors()) { + for (DeclarationDescriptor descriptor : packageFromBinary.getMemberScope().getAllDescriptors()) { if (descriptor instanceof ClassDescriptor) { assert descriptor instanceof DeserializedClassDescriptor : DescriptorUtils.getFQName(descriptor) + " is loaded as " + descriptor.getClass(); } } - validateAndCompareDescriptors(namespaceFromSource, namespaceFromClass, + validateAndCompareDescriptors(packageFromSource, packageFromBinary, RecursiveDescriptorComparator.DONT_INCLUDE_METHODS_OF_OBJECT .checkPrimaryConstructors(true) .checkPropertyAccessors(includeAccessors), txtFile); } - private static void checkUsageOfDeserializedScope(@NotNull NamespaceDescriptor namespaceFromClass) { - JetScope scope = namespaceFromClass.getMemberScope(); - boolean hasOwnMembers = false; - for (DeclarationDescriptor declarationDescriptor : scope.getAllDescriptors()) { - if (declarationDescriptor instanceof CallableMemberDescriptor) { - hasOwnMembers = true; - } - } - if (hasOwnMembers) { - assert scope instanceof DeserializedPackageMemberScope : "If namespace has members, members should be inside deserialized scope."; - } - else { - //NOTE: should probably change - assert !(scope instanceof DeserializedPackageMemberScope) : "We don't use deserialized scopes for namespaces without members."; - } + // TODO 2 do something + private static void checkUsageOfDeserializedScope(@NotNull PackageViewDescriptor packageFromBinary) { + //JetScope scope = packageFromBinary.getMemberScope(); + //boolean hasOwnMembers = false; + //for (DeclarationDescriptor declarationDescriptor : scope.getAllDescriptors()) { + // if (declarationDescriptor instanceof CallableMemberDescriptor) { + // hasOwnMembers = true; + // } + //} + //if (hasOwnMembers) { + // assert scope instanceof DeserializedPackageMemberScope : "If namespace has members, members should be inside deserialized scope."; + //} + //else { + // //NOTE: should probably change + // assert !(scope instanceof DeserializedPackageMemberScope) : "We don't use deserialized scopes for namespaces without members."; + //} } } diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java index b5ac3efc21e..7174aa5c14c 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractLoadJavaTest.java @@ -33,13 +33,12 @@ import org.jetbrains.jet.config.CompilerConfiguration; import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver; import org.jetbrains.jet.di.InjectorForTopDownAnalyzerForJvm; import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl; -import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor; import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; -import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.test.TestCaseWithTmpdir; import org.junit.Assert; @@ -52,7 +51,6 @@ import java.util.List; import java.util.Map; import static org.jetbrains.jet.jvm.compiler.LoadDescriptorUtil.*; -import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_KOTLIN_SOURCES; import static org.jetbrains.jet.test.util.DescriptorValidator.ValidationVisitor.ALLOW_ERROR_TYPES; import static org.jetbrains.jet.test.util.RecursiveDescriptorComparator.*; @@ -66,10 +64,10 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { File javaFile = new File(javaFileName); File ktFile = new File(javaFile.getPath().replaceFirst("\\.java$", ".kt")); File txtFile = getTxtFile(javaFile.getPath()); - NamespaceDescriptor kotlinNamespace = analyzeKotlinAndLoadTestNamespace(ktFile, myTestRootDisposable, ConfigurationKind.ALL); - Pair javaNamespaceAndContext = compileJavaAndLoadTestNamespaceAndBindingContextFromBinary( + PackageViewDescriptor kotlinPackage = analyzeKotlinAndLoadTestPackage(ktFile, myTestRootDisposable, ConfigurationKind.ALL); + Pair javaPackageAndContext = compileJavaAndLoadTestPackageAndBindingContextFromBinary( Arrays.asList(javaFile), tmpdir, myTestRootDisposable, ConfigurationKind.ALL); - checkLoadedNamespaces(txtFile, kotlinNamespace, javaNamespaceAndContext.first, javaNamespaceAndContext.second); + checkLoadedPackages(txtFile, kotlinPackage, javaPackageAndContext.first, javaPackageAndContext.second); } protected void doTestCompiledJava(@NotNull String javaFileName) throws Exception { @@ -105,10 +103,10 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { JetTestUtils.createEnvironmentWithJdkAndNullabilityAnnotationsFromIdea( getTestRootDisposable(), ConfigurationKind.JDK_AND_ANNOTATIONS, TestJdkKind.MOCK_JDK); - Pair javaNamespaceAndContext = compileJavaAndLoadTestNamespaceAndBindingContextFromBinary( + Pair javaPackageAndContext = compileJavaAndLoadTestPackageAndBindingContextFromBinary( srcFiles, compiledDir, getTestRootDisposable(), ConfigurationKind.ALL); - checkJavaNamespace(getTxtFile(javaFileName), javaNamespaceAndContext.first, javaNamespaceAndContext.second, configuration); + checkJavaPackage(getTxtFile(javaFileName), javaPackageAndContext.first, javaPackageAndContext.second, configuration); } protected void doTestSourceJava(@NotNull String javaFileName) throws Exception { @@ -119,11 +117,11 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { assertTrue(testPackageDir.mkdir()); FileUtil.copy(originalJavaFile, new File(testPackageDir, originalJavaFile.getName())); - Pair javaNamespaceAndContext = loadTestNamespaceAndBindingContextFromJavaRoot( + Pair javaNamespaceAndContext = loadTestPackageAndBindingContextFromJavaRoot( tmpdir, getTestRootDisposable(), ConfigurationKind.JDK_ONLY); - checkJavaNamespace(expectedFile, javaNamespaceAndContext.first, javaNamespaceAndContext.second, - DONT_INCLUDE_METHODS_OF_OBJECT.withValidationStrategy(ALLOW_ERROR_TYPES)); + checkJavaPackage(expectedFile, javaNamespaceAndContext.first, javaNamespaceAndContext.second, + DONT_INCLUDE_METHODS_OF_OBJECT.withValidationStrategy(ALLOW_ERROR_TYPES)); } protected void doTestJavaAgainstKotlin(String expectedFileName) throws Exception { @@ -149,6 +147,7 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { InjectorForJavaDescriptorResolver injectorForJava = new InjectorForJavaDescriptorResolver(environment.getProject(), trace); ModuleDescriptorImpl moduleDescriptor = AnalyzerFacadeForJVM.createJavaModule(""); + InjectorForTopDownAnalyzerForJvm injectorForAnalyzer = new InjectorForTopDownAnalyzerForJvm( environment.getProject(), new TopDownAnalysisParameters( @@ -159,21 +158,20 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { injectorForAnalyzer.getTopDownAnalyzer().analyzeFiles(environment.getSourceFiles(), Collections.emptyList()); - JavaDescriptorResolver javaDescriptorResolver = injectorForJava.getJavaDescriptorResolver(); - NamespaceDescriptor namespaceDescriptor = javaDescriptorResolver.resolveNamespace(TEST_PACKAGE_FQNAME, INCLUDE_KOTLIN_SOURCES); - assert namespaceDescriptor != null : "Test namespace not found"; + PackageViewDescriptor packageView = moduleDescriptor.getPackage(TEST_PACKAGE_FQNAME); + assert packageView != null : "Test namespace not found"; - checkJavaNamespace(expectedFile, namespaceDescriptor, trace.getBindingContext(), DONT_INCLUDE_METHODS_OF_OBJECT); + checkJavaPackage(expectedFile, packageView, trace.getBindingContext(), DONT_INCLUDE_METHODS_OF_OBJECT); } private static void checkForLoadErrorsAndCompare( - @NotNull NamespaceDescriptor javaNamespace, + @NotNull PackageViewDescriptor javaPackage, @NotNull BindingContext bindingContext, @NotNull Runnable compareNamespacesRunnable ) { boolean fail = false; try { - ExpectedLoadErrorsUtil.checkForLoadErrors(javaNamespace, bindingContext); + ExpectedLoadErrorsUtil.checkForLoadErrors(javaPackage, bindingContext); } catch (ComparisonFailure e) { // to let the next check run even if this one failed @@ -193,30 +191,30 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir { } } - private static void checkLoadedNamespaces( + private static void checkLoadedPackages( final File txtFile, - final NamespaceDescriptor kotlinNamespace, - final NamespaceDescriptor javaNamespace, + final PackageViewDescriptor kotlinPackage, + final PackageViewDescriptor javaPackage, BindingContext bindingContext ) { - checkForLoadErrorsAndCompare(javaNamespace, bindingContext, new Runnable() { + checkForLoadErrorsAndCompare(javaPackage, bindingContext, new Runnable() { @Override public void run() { - validateAndCompareDescriptors(kotlinNamespace, javaNamespace, DONT_INCLUDE_METHODS_OF_OBJECT, txtFile); + validateAndCompareDescriptors(kotlinPackage, javaPackage, DONT_INCLUDE_METHODS_OF_OBJECT, txtFile); } }); } - private static void checkJavaNamespace( + private static void checkJavaPackage( final File txtFile, - final NamespaceDescriptor javaNamespace, + final PackageViewDescriptor javaPackage, BindingContext bindingContext, final Configuration configuration ) { - checkForLoadErrorsAndCompare(javaNamespace, bindingContext, new Runnable() { + checkForLoadErrorsAndCompare(javaPackage, bindingContext, new Runnable() { @Override public void run() { - validateAndCompareDescriptorWithFile(javaNamespace, configuration, txtFile); + validateAndCompareDescriptorWithFile(javaPackage, configuration, txtFile); } }); } diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.java index 88fe3029aa0..b07755500c8 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/CompileKotlinAgainstCustomBinariesTest.java @@ -23,13 +23,11 @@ import org.jetbrains.jet.ConfigurationKind; import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.MockLibraryUtil; import org.jetbrains.jet.TestJdkKind; +import org.jetbrains.jet.analyzer.AnalyzeExhaust; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.config.CompilerConfiguration; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter; -import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; import org.jetbrains.jet.test.TestCaseWithTmpdir; import org.jetbrains.jet.test.util.DescriptorValidator; @@ -64,28 +62,27 @@ public class CompileKotlinAgainstCustomBinariesTest extends TestCaseWithTmpdir { private void doTestWithTxt(@NotNull File... extraClassPath) throws Exception { File ktFile = new File(getTestDataDirectory(), getTestName(false) + ".kt"); - NamespaceDescriptor namespace = analyzeFileToNamespace(ktFile, extraClassPath); + PackageViewDescriptor packageView = analyzeFileToPackageView(ktFile, extraClassPath); RecursiveDescriptorComparator.Configuration comparator = RecursiveDescriptorComparator.DONT_INCLUDE_METHODS_OF_OBJECT.withValidationStrategy( DescriptorValidator.ValidationVisitor.ALLOW_ERROR_TYPES); File txtFile = new File(getTestDataDirectory(), FileUtil.getNameWithoutExtension(ktFile) + ".txt"); - validateAndCompareDescriptorWithFile(namespace, comparator, txtFile); + validateAndCompareDescriptorWithFile(packageView, comparator, txtFile); } @NotNull - private NamespaceDescriptor analyzeFileToNamespace(@NotNull File ktFile, @NotNull File... extraClassPath) throws IOException { + private PackageViewDescriptor analyzeFileToPackageView(@NotNull File ktFile, @NotNull File... extraClassPath) throws IOException { Project project = createEnvironment(Arrays.asList(extraClassPath)).getProject(); - BindingContext bindingContext = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration( + AnalyzeExhaust exhaust = AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration( JetTestUtils.loadJetFile(project, ktFile), Collections.emptyList() - ).getBindingContext(); + ); - NamespaceDescriptor namespaceDescriptor = bindingContext.get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, - LoadDescriptorUtil.TEST_PACKAGE_FQNAME); - assertNotNull("Failed to find namespace: " + LoadDescriptorUtil.TEST_PACKAGE_FQNAME, namespaceDescriptor); - return namespaceDescriptor; + PackageViewDescriptor packageView = exhaust.getModuleDescriptor().getPackage(LoadDescriptorUtil.TEST_PACKAGE_FQNAME); + assertNotNull("Failed to find namespace: " + LoadDescriptorUtil.TEST_PACKAGE_FQNAME, packageView); + return packageView; } @NotNull @@ -102,7 +99,7 @@ public class CompileKotlinAgainstCustomBinariesTest extends TestCaseWithTmpdir { @NotNull private Collection analyzeAndGetAllDescriptors(@NotNull File... extraClassPath) throws IOException { File ktFile = new File(getTestDataDirectory(), getTestName(true) + ".kt"); - return analyzeFileToNamespace(ktFile, extraClassPath).getMemberScope().getAllDescriptors(); + return analyzeFileToPackageView(ktFile, extraClassPath).getMemberScope().getAllDescriptors(); } @NotNull diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/ExpectedLoadErrorsUtil.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/ExpectedLoadErrorsUtil.java index 4435573211e..c751921baa7 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/ExpectedLoadErrorsUtil.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/ExpectedLoadErrorsUtil.java @@ -38,10 +38,10 @@ public class ExpectedLoadErrorsUtil { public static final String ANNOTATION_CLASS_NAME = ExpectLoadError.class.getName(); public static void checkForLoadErrors( - @NotNull NamespaceDescriptor namespaceFromJava, + @NotNull PackageViewDescriptor packageFromJava, @NotNull BindingContext bindingContext ) { - Map> expectedErrors = getExpectedLoadErrors(namespaceFromJava); + Map> expectedErrors = getExpectedLoadErrors(packageFromJava); Map> actualErrors = getActualLoadErrors(bindingContext); for (DeclarationDescriptor descriptor : ContainerUtil.union(expectedErrors.keySet(), actualErrors.keySet())) { @@ -56,15 +56,10 @@ public class ExpectedLoadErrorsUtil { } } - private static Map> getExpectedLoadErrors(@NotNull NamespaceDescriptor namespaceFromJava) { + private static Map> getExpectedLoadErrors(@NotNull PackageViewDescriptor packageFromJava) { final Map> map = new HashMap>(); - namespaceFromJava.acceptVoid(new DeclarationDescriptorVisitorEmptyBodies() { - @Override - public Void visitNamespaceDescriptor(NamespaceDescriptor descriptor, Void data) { - return visitDeclarationRecursively(descriptor, descriptor.getMemberScope()); - } - + packageFromJava.acceptVoid(new DeclarationDescriptorVisitorEmptyBodies() { @Override public Void visitPackageViewDescriptor(PackageViewDescriptor descriptor, Void data) { return visitDeclarationRecursively(descriptor, descriptor.getMemberScope()); diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java index 0061b388555..63dfc113bf1 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java @@ -31,7 +31,7 @@ import org.jetbrains.jet.codegen.GenerationUtils; import org.jetbrains.jet.codegen.state.GenerationState; import org.jetbrains.jet.config.CompilerConfiguration; import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver; -import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter; import org.jetbrains.jet.lang.resolve.BindingContext; @@ -47,7 +47,6 @@ import java.util.Collection; import java.util.Collections; import static org.jetbrains.jet.JetTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations; -import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.IGNORE_KOTLIN_SOURCES; public final class LoadDescriptorUtil { @@ -73,7 +72,7 @@ public final class LoadDescriptorUtil { } @NotNull - public static Pair loadTestNamespaceAndBindingContextFromJavaRoot( + public static Pair loadTestPackageAndBindingContextFromJavaRoot( @NotNull File javaRoot, @NotNull Disposable disposable, @NotNull ConfigurationKind configurationKind @@ -87,15 +86,14 @@ public final class LoadDescriptorUtil { JetCoreEnvironment jetCoreEnvironment = JetCoreEnvironment.createForTests(disposable, configuration); BindingTraceContext trace = new BindingTraceContext(); InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(jetCoreEnvironment.getProject(), trace); - NamespaceDescriptor namespaceDescriptor = - injector.getJavaDescriptorResolver().resolveNamespace(TEST_PACKAGE_FQNAME, IGNORE_KOTLIN_SOURCES); - assert namespaceDescriptor != null; + PackageViewDescriptor packageView = injector.getModule().getPackage(TEST_PACKAGE_FQNAME); + assert packageView != null; - return Pair.create(namespaceDescriptor, trace.getBindingContext()); + return Pair.create(packageView, trace.getBindingContext()); } @NotNull - public static Pair compileJavaAndLoadTestNamespaceAndBindingContextFromBinary( + public static Pair compileJavaAndLoadTestPackageAndBindingContextFromBinary( @NotNull Collection javaFiles, @NotNull File outDir, @NotNull Disposable disposable, @@ -103,7 +101,7 @@ public final class LoadDescriptorUtil { ) throws IOException { compileJavaWithAnnotationsJar(javaFiles, outDir); - return loadTestNamespaceAndBindingContextFromJavaRoot(outDir, disposable, configurationKind); + return loadTestPackageAndBindingContextFromJavaRoot(outDir, disposable, configurationKind); } private static void compileJavaWithAnnotationsJar(@NotNull Collection javaFiles, @NotNull File outDir) throws IOException { @@ -117,12 +115,16 @@ public final class LoadDescriptorUtil { } @NotNull - public static NamespaceDescriptor analyzeKotlinAndLoadTestNamespace(@NotNull File ktFile, @NotNull Disposable disposable, @NotNull ConfigurationKind configurationKind) throws Exception { + public static PackageViewDescriptor analyzeKotlinAndLoadTestPackage( + @NotNull File ktFile, + @NotNull Disposable disposable, + @NotNull ConfigurationKind configurationKind + ) throws Exception { JetFileAndExhaust fileAndExhaust = JetFileAndExhaust.createJetFileAndAnalyze(ktFile, disposable, configurationKind); - NamespaceDescriptor namespace = - fileAndExhaust.getExhaust().getBindingContext().get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, TEST_PACKAGE_FQNAME); - assert namespace != null: TEST_PACKAGE_FQNAME + " package not found in " + ktFile.getName(); - return namespace; + PackageViewDescriptor packageView = + fileAndExhaust.getExhaust().getModuleDescriptor().getPackage(TEST_PACKAGE_FQNAME); + assert packageView != null: TEST_PACKAGE_FQNAME + " package not found in " + ktFile.getName(); + return packageView; } private static class JetFileAndExhaust { diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java index 7a43f4be112..c98cca9855f 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDescriptorRendererTest.java @@ -54,7 +54,7 @@ public abstract class AbstractLazyResolveDescriptorRendererTest extends KotlinTe JetFile psiFile = JetPsiFactory.createFile(getProject(), FileUtil.loadFile(new File(testFile), true)); Collection files = Lists.newArrayList(psiFile); - ModuleDescriptorImpl lazyModule = AnalyzerFacadeForJVM.createJavaModule(""); + final ModuleDescriptorImpl lazyModule = AnalyzerFacadeForJVM.createJavaModule(""); lazyModule.setModuleConfiguration(injectorForTopDownAnalyzer.getModuleDescriptor().getModuleConfiguration()); LockBasedLazyResolveStorageManager storageManager = new LockBasedLazyResolveStorageManager(); final ResolveSession resolveSession = new ResolveSession(getProject(), storageManager, lazyModule, @@ -64,9 +64,9 @@ public abstract class AbstractLazyResolveDescriptorRendererTest extends KotlinTe psiFile.accept(new JetVisitorVoid() { @Override public void visitJetFile(@NotNull JetFile file) { - String qualifiedName = file.getNamespaceHeader().getQualifiedName(); - if (!qualifiedName.isEmpty()) { - NamespaceDescriptor packageDescriptor = resolveSession.getPackageDescriptorByFqName(new FqName(qualifiedName)); + FqName fqName = file.getNamespaceHeader().getFqName(); + if (!fqName.isRoot()) { + PackageViewDescriptor packageDescriptor = lazyModule.getPackage(fqName); descriptors.add(packageDescriptor); } file.acceptChildren(this); diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDiagnosticsTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDiagnosticsTest.java index f7f0eeeaf85..9f63b9899cf 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDiagnosticsTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveDiagnosticsTest.java @@ -22,6 +22,7 @@ import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.checkers.AbstractJetDiagnosticsTest; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; @@ -45,8 +46,8 @@ public abstract class AbstractLazyResolveDiagnosticsTest extends AbstractJetDiag ModuleDescriptor eagerModule = LazyResolveTestUtil.resolveEagerly(jetFiles, getEnvironment()); String path = JetTestUtils.getFilePath(new File(FileUtil.getRelativePath(TEST_DATA_DIR, testDataFile))); - NamespaceDescriptor expected = eagerModule.getNamespace(FqName.ROOT); - NamespaceDescriptor actual = lazyModule.getNamespace(FqName.ROOT); + PackageViewDescriptor expected = eagerModule.getPackage(FqName.ROOT); + PackageViewDescriptor actual = lazyModule.getPackage(FqName.ROOT); String txtFileRelativePath = path.replaceAll("\\.kt$|\\.ktscript", ".txt"); File txtFile = new File("compiler/testData/lazyResolve/diagnostics/" + txtFileRelativePath); diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveNamespaceComparingTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveNamespaceComparingTest.java index 42f6215c669..bcbc1b039db 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveNamespaceComparingTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveNamespaceComparingTest.java @@ -23,6 +23,7 @@ import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.resolve.name.FqName; @@ -73,10 +74,10 @@ public abstract class AbstractLazyResolveNamespaceComparingTest extends KotlinTe FqName test = new FqName("test"); - NamespaceDescriptor actual = lazyModule.getNamespace(test); + PackageViewDescriptor actual = lazyModule.getPackage(test); Assert.assertNotNull("Namespace for name " + test + " is null after lazy resolve", actual); - NamespaceDescriptor expected = eagerModule.getNamespace(test); + PackageViewDescriptor expected = eagerModule.getPackage(test); Assert.assertNotNull("Namespace for name " + test + " is null after eager resolve", expected); File serializeResultsTo = new File(FileUtil.getNameWithoutExtension(testFileName) + ".txt"); diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveTest.java index ac3aa666b92..9d1914ad139 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyResolveTest.java @@ -24,10 +24,9 @@ import org.jetbrains.jet.ConfigurationKind; import org.jetbrains.jet.JetLiteFixture; import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; -import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.name.FqName; -import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.resolve.ExpectedResolveData; import org.jetbrains.jet.resolve.JetExpectedResolveDataUtil; @@ -75,7 +74,7 @@ public abstract class AbstractLazyResolveTest extends JetLiteFixture { KotlinCodeAnalyzer resolveSession = LazyResolveTestUtil.resolveLazilyWithSession(files, getEnvironment(), true); - NamespaceDescriptor actual = resolveSession.getPackageDescriptorByFqName(new FqName("test")); + PackageViewDescriptor actual = resolveSession.getModuleDescriptor().getPackage(new FqName("test")); Assert.assertNotNull("Package 'test' was not found", actual); resolveSession.forceResolveAll(); diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveBuiltinClassesTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveBuiltinClassesTest.java index cb86b46341e..82d48f78b0a 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveBuiltinClassesTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveBuiltinClassesTest.java @@ -18,7 +18,7 @@ package org.jetbrains.jet.lang.resolve.lazy; import org.jetbrains.jet.ConfigurationKind; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; -import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import java.io.File; @@ -33,7 +33,7 @@ public class LazyResolveBuiltinClassesTest extends KotlinTestWithEnvironment { } public void testBuiltIns() throws Exception { - NamespaceDescriptor builtInsPackage = KotlinBuiltIns.getInstance().getBuiltInsPackage(); + PackageFragmentDescriptor builtInsPackage = KotlinBuiltIns.getInstance().getBuiltInsPackageFragment(); validateAndCompareDescriptorWithFile(builtInsPackage, RECURSIVE_ALL, new File("compiler/testData/builtin-classes.txt")); } } diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveStdlibLoadingTest.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveStdlibLoadingTest.java index 4f58d7c7387..d8360ec2653 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveStdlibLoadingTest.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveStdlibLoadingTest.java @@ -23,6 +23,7 @@ import org.jetbrains.jet.TestJdkKind; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; @@ -52,8 +53,8 @@ public class LazyResolveStdlibLoadingTest extends KotlinTestWithEnvironmentManag ModuleDescriptor lazyModule = LazyResolveTestUtil.resolveLazily(files, stdlibEnvironment); for (Name name : namespaceShortNames) { - NamespaceDescriptor eager = module.getNamespace(FqName.topLevel(name)); - NamespaceDescriptor lazy = lazyModule.getNamespace(FqName.topLevel(name)); + PackageViewDescriptor eager = module.getPackage(FqName.topLevel(name)); + PackageViewDescriptor lazy = lazyModule.getPackage(FqName.topLevel(name)); RecursiveDescriptorComparator.validateAndCompareDescriptors(eager, lazy, RecursiveDescriptorComparator.RECURSIVE, null); } } diff --git a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java index e1b18b4cfb4..d42c0a44d31 100644 --- a/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java +++ b/compiler/tests/org/jetbrains/jet/lang/resolve/lazy/LazyResolveTestUtil.java @@ -90,7 +90,7 @@ public class LazyResolveTestUtil { } public static ModuleDescriptor resolveLazily(List files, JetCoreEnvironment environment, boolean addBuiltIns) { - return resolveLazilyWithSession(files, environment, addBuiltIns).getRootModuleDescriptor(); + return resolveLazilyWithSession(files, environment, addBuiltIns).getModuleDescriptor(); } @NotNull diff --git a/compiler/tests/org/jetbrains/jet/renderer/DescriptorRendererTest.java b/compiler/tests/org/jetbrains/jet/renderer/DescriptorRendererTest.java index 7f572f8b646..cade2832dd8 100644 --- a/compiler/tests/org/jetbrains/jet/renderer/DescriptorRendererTest.java +++ b/compiler/tests/org/jetbrains/jet/renderer/DescriptorRendererTest.java @@ -27,12 +27,14 @@ import org.jetbrains.jet.analyzer.AnalyzeExhaust; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; +import org.jetbrains.jet.lang.descriptors.PackageViewDescriptor; import org.jetbrains.jet.lang.psi.JetElement; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.psi.JetVisitorVoid; import org.jetbrains.jet.lang.resolve.AnalyzerScriptParameter; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM; +import org.jetbrains.jet.lang.resolve.name.FqName; import java.io.IOException; import java.util.ArrayList; @@ -94,6 +96,13 @@ public class DescriptorRendererTest extends JetLiteFixture { AnalyzerFacadeForJVM.analyzeOneFileWithJavaIntegration(psiFile, Collections.emptyList()); final BindingContext bindingContext = analyzeExhaust.getBindingContext(); final List descriptors = new ArrayList(); + + FqName fqName = psiFile.getNamespaceHeader().getFqName(); + if (!fqName.isRoot()) { + PackageViewDescriptor packageDescriptor = analyzeExhaust.getModuleDescriptor().getPackage(fqName); + descriptors.add(packageDescriptor); + } + psiFile.acceptChildren(new JetVisitorVoid() { @Override public void visitJetElement(@NotNull JetElement element) { diff --git a/compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java b/compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java index 8217d1f5823..3992c73cba0 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java +++ b/compiler/tests/org/jetbrains/jet/resolve/ExpectedResolveData.java @@ -261,7 +261,7 @@ public abstract class ExpectedResolveData { } assert expected != null : "No declaration for " + name; - if (referenceTarget instanceof NamespaceDescriptor) { + if (referenceTarget instanceof PackageViewDescriptor) { JetNamespaceHeader expectedHeader = PsiTreeUtil.getParentOfType(expected, JetNamespaceHeader.class); FqName expectedFqName; if (expectedHeader != null) { @@ -275,7 +275,7 @@ public abstract class ExpectedResolveData { else { throw new IllegalStateException(expected.getClass().getName() + " name=" + name); } - assertEquals(expectedFqName, ((NamespaceDescriptor) referenceTarget).getFqName()); + assertEquals(expectedFqName, ((PackageViewDescriptor) referenceTarget).getFqName()); continue; } diff --git a/compiler/tests/org/jetbrains/jet/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java b/compiler/tests/org/jetbrains/jet/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java index 63ebefe8e0f..07e4066e11a 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java +++ b/compiler/tests/org/jetbrains/jet/resolve/annotation/AbstractAnnotationDescriptorResolveTest.java @@ -22,6 +22,7 @@ import com.intellij.util.Function; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.JetLiteFixture; import org.jetbrains.jet.JetTestUtils; +import org.jetbrains.jet.analyzer.AnalyzeExhaust; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; @@ -44,9 +45,10 @@ import java.util.List; public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFixture { private static final String PATH = "compiler/testData/resolveAnnotations/testFile.kt"; - private static final FqName NAMESPACE = new FqName("test"); + private static final FqName PACKAGE = new FqName("test"); protected BindingContext context; + protected AnalyzeExhaust analyzeExhaust; @Override protected JetCoreEnvironment createEnvironment() { @@ -54,7 +56,7 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFix } protected void doTest(@NotNull String content, @NotNull String expectedAnnotation) { - NamespaceDescriptor test = getNamespaceDescriptor(content); + PackageViewDescriptor test = getPackage(content); ClassDescriptor myClass = getClassDescriptor(test, "MyClass"); checkDescriptor(expectedAnnotation, myClass); checkDescriptor(expectedAnnotation, getClassObjectDescriptor(myClass)); @@ -97,11 +99,11 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFix } @NotNull - private static FunctionDescriptor getFunctionDescriptor(@NotNull NamespaceDescriptor namespaceDescriptor, @NotNull String name) { + protected static FunctionDescriptor getFunctionDescriptor(@NotNull PackageViewDescriptor packageView, @NotNull String name) { Name functionName = Name.identifier(name); - JetScope memberScope = namespaceDescriptor.getMemberScope(); + JetScope memberScope = packageView.getMemberScope(); Collection functions = memberScope.getFunctions(functionName); - assert functions.size() == 1 : "Failed to find function " + functionName + " in class" + "." + namespaceDescriptor.getName(); + assert functions.size() == 1 : "Failed to find function " + functionName + " in class" + "." + packageView.getName(); return functions.iterator().next(); } @@ -115,11 +117,11 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFix } @NotNull - protected static PropertyDescriptor getPropertyDescriptor(@NotNull NamespaceDescriptor namespaceDescriptor, @NotNull String name) { + protected static PropertyDescriptor getPropertyDescriptor(@NotNull PackageViewDescriptor packageView, @NotNull String name) { Name propertyName = Name.identifier(name); - JetScope memberScope = namespaceDescriptor.getMemberScope(); + JetScope memberScope = packageView.getMemberScope(); Collection properties = memberScope.getProperties(propertyName); - assert properties.size() == 1 : "Failed to find property " + propertyName + " in class " + namespaceDescriptor.getName(); + assert properties.size() == 1 : "Failed to find property " + propertyName + " in class " + packageView.getName(); return (PropertyDescriptor) properties.iterator().next(); } @@ -133,10 +135,10 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFix } @NotNull - protected static ClassDescriptor getClassDescriptor(@NotNull NamespaceDescriptor namespaceDescriptor, @NotNull String name) { + protected static ClassDescriptor getClassDescriptor(@NotNull PackageViewDescriptor packageView, @NotNull String name) { Name className = Name.identifier(name); - ClassifierDescriptor aClass = namespaceDescriptor.getMemberScope().getClassifier(className); - assertNotNull("Failed to find class: " + namespaceDescriptor.getName() + "." + className, aClass); + ClassifierDescriptor aClass = packageView.getMemberScope().getClassifier(className); + assertNotNull("Failed to find class: " + packageView.getName() + "." + className, aClass); assert aClass instanceof ClassDescriptor : "Not a class: " + aClass; return (ClassDescriptor) aClass; } @@ -257,13 +259,14 @@ public abstract class AbstractAnnotationDescriptorResolveTest extends JetLiteFix } @NotNull - protected NamespaceDescriptor getNamespaceDescriptor(@NotNull String content) { + protected PackageViewDescriptor getPackage(@NotNull String content) { JetFile ktFile = JetTestUtils.createFile("dummy.kt", content, getProject()); - context = JetTestUtils.analyzeFile(ktFile).getBindingContext(); + analyzeExhaust = JetTestUtils.analyzeFile(ktFile); + context = analyzeExhaust.getBindingContext(); - NamespaceDescriptor namespaceDescriptor = context.get(BindingContext.FQNAME_TO_NAMESPACE_DESCRIPTOR, NAMESPACE); - assertNotNull("Failed to find namespace: " + NAMESPACE, namespaceDescriptor); - return namespaceDescriptor; + PackageViewDescriptor packageView = analyzeExhaust.getModuleDescriptor().getPackage(PACKAGE); + assertNotNull("Failed to find namespace: " + PACKAGE, packageView); + return packageView; } protected static String getContent(@NotNull String annotationText) throws IOException { diff --git a/compiler/tests/org/jetbrains/jet/resolve/annotation/AbstractAnnotationParameterTest.kt b/compiler/tests/org/jetbrains/jet/resolve/annotation/AbstractAnnotationParameterTest.kt index 25a532c6abc..f31d9027b62 100644 --- a/compiler/tests/org/jetbrains/jet/resolve/annotation/AbstractAnnotationParameterTest.kt +++ b/compiler/tests/org/jetbrains/jet/resolve/annotation/AbstractAnnotationParameterTest.kt @@ -24,8 +24,8 @@ import org.jetbrains.jet.JetTestUtils public abstract class AbstractAnnotationParameterTest : AbstractAnnotationDescriptorResolveTest() { fun doTest(path: String) { val fileText = FileUtil.loadFile(File(path)) - val namespaceDescriptor = getNamespaceDescriptor(fileText) - val classDescriptor = AbstractAnnotationDescriptorResolveTest.getClassDescriptor(namespaceDescriptor, "MyClass") + val packageView = getPackage(fileText) + val classDescriptor = AbstractAnnotationDescriptorResolveTest.getClassDescriptor(packageView, "MyClass") val expected = InTextDirectivesUtils.findListWithPrefixes(fileText, "// EXPECTED: ").makeString(", ") val actual = AbstractAnnotationDescriptorResolveTest.getAnnotations(classDescriptor) diff --git a/compiler/tests/org/jetbrains/jet/test/util/DescriptorValidator.java b/compiler/tests/org/jetbrains/jet/test/util/DescriptorValidator.java index a0524dfc746..3a24eaf808c 100644 --- a/compiler/tests/org/jetbrains/jet/test/util/DescriptorValidator.java +++ b/compiler/tests/org/jetbrains/jet/test/util/DescriptorValidator.java @@ -356,12 +356,13 @@ public class DescriptorValidator { private void assertFound( @NotNull JetScope scope, @NotNull DeclarationDescriptor expected, - @Nullable DeclarationDescriptor found + @Nullable DeclarationDescriptor found, + boolean shouldBeSame ) { if (found == null) { report(expected, "Not found in " + scope); } - if (expected != found) { + if (shouldBeSame ? expected != found : !expected.equals(found)) { report(expected, "Lookup error in " + scope + ": " + found); } } @@ -380,8 +381,7 @@ public class DescriptorValidator { public Void visitNamespaceDescriptor( NamespaceDescriptor descriptor, JetScope scope ) { - assertFound(scope, descriptor, scope.getNamespace(descriptor.getName())); - return null; + throw new IllegalStateException("namespace don't exist"); } @Override @@ -395,8 +395,7 @@ public class DescriptorValidator { public Void visitPackageViewDescriptor( PackageViewDescriptor descriptor, JetScope scope ) { - // TODO - //assertFound(scope, descriptor, scope.getPackage(descriptor.getName())); + assertFound(scope, descriptor, scope.getPackage(descriptor.getName()), false); return null; } @@ -420,7 +419,7 @@ public class DescriptorValidator { public Void visitTypeParameterDescriptor( TypeParameterDescriptor descriptor, JetScope scope ) { - assertFound(scope, descriptor, scope.getClassifier(descriptor.getName())); + assertFound(scope, descriptor, scope.getClassifier(descriptor.getName()), true); return null; } @@ -428,7 +427,7 @@ public class DescriptorValidator { public Void visitClassDescriptor( ClassDescriptor descriptor, JetScope scope ) { - assertFound(scope, descriptor, scope.getClassifier(descriptor.getName())); + assertFound(scope, descriptor, scope.getClassifier(descriptor.getName()), true); return null; } diff --git a/compiler/tests/org/jetbrains/jet/test/util/RecursiveDescriptorComparator.java b/compiler/tests/org/jetbrains/jet/test/util/RecursiveDescriptorComparator.java index bfa2722b26a..f52ea22b684 100644 --- a/compiler/tests/org/jetbrains/jet/test/util/RecursiveDescriptorComparator.java +++ b/compiler/tests/org/jetbrains/jet/test/util/RecursiveDescriptorComparator.java @@ -26,7 +26,6 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.jvm.compiler.ExpectedLoadErrorsUtil; import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.MemberComparator; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; @@ -78,14 +77,14 @@ public class RecursiveDescriptorComparator { } private void appendDeclarationRecursively(@NotNull DeclarationDescriptor descriptor, @NotNull Printer printer, boolean topLevel) { - if (descriptor instanceof ClassOrNamespaceDescriptor && !topLevel) { + if ((descriptor instanceof ClassOrNamespaceDescriptor || descriptor instanceof PackageViewDescriptor) && !topLevel) { printer.println(); } boolean isPrimaryConstructor = descriptor instanceof ConstructorDescriptor && ((ConstructorDescriptor) descriptor).isPrimary(); printer.print(isPrimaryConstructor && conf.checkPrimaryConstructors ? "/*primary*/ " : "", conf.renderer.render(descriptor)); - if (descriptor instanceof ClassOrNamespaceDescriptor) { + if (descriptor instanceof ClassOrNamespaceDescriptor || descriptor instanceof PackageViewDescriptor) { if (!topLevel) { printer.printlnWithNoIndent(" {").pushIndent(); } @@ -98,8 +97,12 @@ public class RecursiveDescriptorComparator { ClassDescriptor klass = (ClassDescriptor) descriptor; appendSubDescriptors(klass.getDefaultType().getMemberScope(), getConstructorsAndClassObject(klass), printer); } - else if (descriptor instanceof NamespaceDescriptor) { - appendSubDescriptors(((NamespaceDescriptor) descriptor).getMemberScope(), + else if (descriptor instanceof PackageFragmentDescriptor) { + appendSubDescriptors(((PackageFragmentDescriptor) descriptor).getMemberScope(), + Collections.emptyList(), printer); + } + else if (descriptor instanceof PackageViewDescriptor) { + appendSubDescriptors(((PackageViewDescriptor) descriptor).getMemberScope(), Collections.emptyList(), printer); } @@ -142,7 +145,7 @@ public class RecursiveDescriptorComparator { && JAVA_OBJECT_METHOD_NAMES.contains(subDescriptor.getName().asString()) && !conf.includeMethodsOfJavaObject || - subDescriptor instanceof NamespaceDescriptor && !conf.recurseIntoPackage.apply(DescriptorUtils.getFQName(subDescriptor)); + subDescriptor instanceof PackageViewDescriptor && !conf.recurseIntoPackage.apply(((PackageViewDescriptor) subDescriptor).getFqName().toUnsafe()); // TODO 2 accept safe fq name instead } private void appendSubDescriptors( @@ -216,7 +219,6 @@ public class RecursiveDescriptorComparator { if (expected != null) { String expectedSerialized = comparator.serializeRecursively(expected); - Assert.assertSame(expected.getClass(), actual.getClass()); Assert.assertEquals("Expected and actual descriptors differ", expectedSerialized, actualSerialized); } diff --git a/compiler/tests/org/jetbrains/jet/test/util/RecursiveDescriptorProcessor.java b/compiler/tests/org/jetbrains/jet/test/util/RecursiveDescriptorProcessor.java index 3a51d007244..ff0e1114e3c 100644 --- a/compiler/tests/org/jetbrains/jet/test/util/RecursiveDescriptorProcessor.java +++ b/compiler/tests/org/jetbrains/jet/test/util/RecursiveDescriptorProcessor.java @@ -118,7 +118,7 @@ public class RecursiveDescriptorProcessor { @Override public Boolean visitModuleDeclaration(ModuleDescriptor descriptor, D data) { return applyWorker(descriptor, data) - && visitChildren(descriptor.getNamespace(FqName.ROOT), data); + && visitChildren(descriptor.getPackage(FqName.ROOT), data); } @Override diff --git a/compiler/tests/org/jetbrains/jet/test/util/RecursiveDescriptorProcessorTest.java b/compiler/tests/org/jetbrains/jet/test/util/RecursiveDescriptorProcessorTest.java index bc7f97b4b77..a1493a684bb 100644 --- a/compiler/tests/org/jetbrains/jet/test/util/RecursiveDescriptorProcessorTest.java +++ b/compiler/tests/org/jetbrains/jet/test/util/RecursiveDescriptorProcessorTest.java @@ -44,7 +44,7 @@ public class RecursiveDescriptorProcessorTest extends KotlinTestWithEnvironment String text = FileUtil.loadFile(ktFile); JetFile jetFile = JetTestUtils.createFile("declarations.kt", text, getEnvironment().getProject()); AnalyzeExhaust exhaust = JetTestUtils.analyzeFile(jetFile); - NamespaceDescriptor testPackage = exhaust.getModuleDescriptor().getNamespace(FqName.topLevel(Name.identifier("test"))); + PackageViewDescriptor testPackage = exhaust.getModuleDescriptor().getPackage(FqName.topLevel(Name.identifier("test"))); assert testPackage != null; List descriptors = recursivelyCollectDescriptors(testPackage); @@ -74,7 +74,7 @@ public class RecursiveDescriptorProcessorTest extends KotlinTestWithEnvironment return closestInterface(aClass.getSuperclass()); } - private static List recursivelyCollectDescriptors(NamespaceDescriptor testPackage) { + private static List recursivelyCollectDescriptors(PackageViewDescriptor testPackage) { final List lines = Lists.newArrayList(); RecursiveDescriptorProcessor.process(testPackage, null, new DeclarationDescriptorVisitor() { @@ -98,9 +98,7 @@ public class RecursiveDescriptorProcessorTest extends KotlinTestWithEnvironment } @Override - public Boolean visitPackageFragmentDescriptor( - PackageFragmentDescriptor descriptor, Void data - ) { + public Boolean visitPackageFragmentDescriptor(PackageFragmentDescriptor descriptor, Void data) { add(descriptor); return true; } diff --git a/compiler/tests/org/jetbrains/jet/types/BoundsSubstitutorTest.java b/compiler/tests/org/jetbrains/jet/types/BoundsSubstitutorTest.java index 89d8fdac9b6..7100bf07647 100644 --- a/compiler/tests/org/jetbrains/jet/types/BoundsSubstitutorTest.java +++ b/compiler/tests/org/jetbrains/jet/types/BoundsSubstitutorTest.java @@ -72,7 +72,7 @@ public class BoundsSubstitutorTest extends KotlinTestWithEnvironment { private void doTest(String text, String expected) { JetFile jetFile = JetPsiFactory.createFile(getProject(), "fun.kt", text); ModuleDescriptor module = LazyResolveTestUtil.resolveLazily(Collections.singletonList(jetFile), getEnvironment()); - Collection functions = module.getNamespace(FqName.ROOT).getMemberScope().getFunctions(Name.identifier("f")); + Collection functions = module.getPackage(FqName.ROOT).getMemberScope().getFunctions(Name.identifier("f")); assert functions.size() == 1 : "Many functions defined"; FunctionDescriptor function = ContainerUtil.getFirstItem(functions); diff --git a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java index 82f0597fc26..45d37fd85d5 100644 --- a/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java +++ b/compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java @@ -28,12 +28,13 @@ import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.di.InjectorForJavaDescriptorResolver; import org.jetbrains.jet.di.InjectorForTests; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; -import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor; import org.jetbrains.jet.lang.descriptors.ReceiverParameterDescriptor; import org.jetbrains.jet.lang.descriptors.impl.ReceiverParameterDescriptorImpl; import org.jetbrains.jet.lang.psi.JetExpression; import org.jetbrains.jet.lang.psi.JetPsiFactory; import org.jetbrains.jet.lang.resolve.BindingTraceContext; +import org.jetbrains.jet.lang.resolve.ImportPath; import org.jetbrains.jet.lang.resolve.TypeResolver; import org.jetbrains.jet.lang.resolve.calls.autocasts.DataFlowInfo; import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; @@ -52,9 +53,6 @@ import java.io.File; import java.io.IOException; import java.util.*; -import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.IGNORE_KOTLIN_SOURCES; -import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_KOTLIN_SOURCES; - public class JetTypeCheckerTest extends JetLiteFixture { private KotlinBuiltIns builtIns; @@ -578,7 +576,7 @@ public class JetTypeCheckerTest extends JetLiteFixture { getEnvironment() ); - NamespaceDescriptor testData = moduleDescriptor.getNamespace(new FqName("testData")); + PackageFragmentDescriptor testData = moduleDescriptor.getPackageFragmentProvider().getPackageFragments(new FqName("testData")).get(0); // TODO 2 hack return addImports(testData.getMemberScope()); } @@ -588,10 +586,12 @@ public class JetTypeCheckerTest extends JetLiteFixture { scope, scope.getContainingDeclaration(), RedeclarationHandler.DO_NOTHING, "JetTypeCheckerTest.addImports"); InjectorForJavaDescriptorResolver injector = new InjectorForJavaDescriptorResolver(getProject(), new BindingTraceContext()); JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver(); - writableScope.importScope(javaDescriptorResolver.resolveNamespace(FqName.ROOT, INCLUDE_KOTLIN_SOURCES).getMemberScope()); - writableScope.importScope(javaDescriptorResolver.resolveNamespace(new FqName("java.lang"), IGNORE_KOTLIN_SOURCES).getMemberScope()); + ModuleDescriptor module = javaDescriptorResolver.getPackageFragmentProvider().getModule(); + for (ImportPath defaultImport : module.getDefaultImports()) { + writableScope.importScope(module.getPackage(defaultImport.fqnPart()).getMemberScope()); + } + writableScope.importScope(module.getPackage(FqName.ROOT).getMemberScope()); writableScope.changeLockLevel(WritableScope.LockLevel.BOTH); - writableScope.importScope(builtIns.getBuiltInsScope()); return writableScope; } diff --git a/compiler/tests/org/jetbrains/jet/types/TypeSubstitutorTest.java b/compiler/tests/org/jetbrains/jet/types/TypeSubstitutorTest.java index 762c5571ed3..75a65bc5575 100644 --- a/compiler/tests/org/jetbrains/jet/types/TypeSubstitutorTest.java +++ b/compiler/tests/org/jetbrains/jet/types/TypeSubstitutorTest.java @@ -83,7 +83,7 @@ public class TypeSubstitutorTest extends KotlinTestWithEnvironment { String text = FileUtil.loadFile(new File("compiler/testData/type-substitutor.kt")); JetFile jetFile = JetPsiFactory.createFile(getProject(), text); ModuleDescriptor module = LazyResolveTestUtil.resolveLazily(Collections.singletonList(jetFile), getEnvironment()); - JetScope topLevelDeclarations = module.getNamespace(FqName.ROOT).getMemberScope(); + JetScope topLevelDeclarations = module.getPackage(FqName.ROOT).getMemberScope(); ClassifierDescriptor contextClass = topLevelDeclarations.getClassifier(Name.identifier("___Context")); assert contextClass instanceof ClassDescriptor; WritableScopeImpl typeParameters = new WritableScopeImpl(JetScope.EMPTY, module, RedeclarationHandler.THROW_EXCEPTION, diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/JavaBridgeConfiguration.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/JavaBridgeConfiguration.java index e813715c01a..306867f20cc 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/JavaBridgeConfiguration.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/JavaBridgeConfiguration.java @@ -42,19 +42,7 @@ public class JavaBridgeConfiguration implements ModuleConfiguration { ALL_JAVA_IMPORTS = Collections.unmodifiableList(allJavaImports); } - private JavaDescriptorResolver javaDescriptorResolver; - - @Inject - public void setJavaDescriptorResolver(@NotNull JavaDescriptorResolver javaDescriptorResolver) { - this.javaDescriptorResolver = javaDescriptorResolver; - } - @Override public void extendNamespaceScope(@NotNull NamespaceDescriptor namespaceDescriptor, @NotNull WritableScope namespaceMemberScope) { - JetScope javaPackageScope = javaDescriptorResolver.getJavaPackageScope(namespaceDescriptor); - if (javaPackageScope != null) { - namespaceMemberScope.importScope(javaPackageScope); - } - DefaultModuleConfiguration.INSTANCE.extendNamespaceScope(namespaceDescriptor, namespaceMemberScope); } } diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java index d1a9531c67a..805df8655ca 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java @@ -21,10 +21,9 @@ import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProvider; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; -import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolver; import javax.inject.Inject; @@ -35,7 +34,7 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes public static final Name JAVA_ROOT = Name.special(""); private JavaClassResolver classResolver; - private JavaNamespaceResolver namespaceResolver; + private JavaPackageFragmentProvider packageFragmentProvider; @Inject public void setClassResolver(JavaClassResolver classResolver) { @@ -43,8 +42,8 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes } @Inject - public void setNamespaceResolver(JavaNamespaceResolver namespaceResolver) { - this.namespaceResolver = namespaceResolver; + public void setPackageFragmentProvider(JavaPackageFragmentProvider packageFragmentProvider) { + this.packageFragmentProvider = packageFragmentProvider; } @Nullable @@ -57,13 +56,15 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes return classResolver.resolveClass(qualifiedName, IGNORE_KOTLIN_SOURCES); } + @Deprecated @Nullable public NamespaceDescriptor resolveNamespace(@NotNull FqName qualifiedName, @NotNull DescriptorSearchRule searchRule) { - return namespaceResolver.resolveNamespace(qualifiedName, searchRule); + // TODO 1 remove this method + return null; } - @Nullable - public JetScope getJavaPackageScope(@NotNull NamespaceDescriptor namespaceDescriptor) { - return namespaceResolver.getJavaPackageScopeForExistingNamespaceDescriptor(namespaceDescriptor); + @NotNull + public JavaPackageFragmentProvider getPackageFragmentProvider() { + return packageFragmentProvider; } } diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/JavaVisibilities.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/JavaVisibilities.java index 217d47e3a49..02b61e54b81 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/JavaVisibilities.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/JavaVisibilities.java @@ -17,10 +17,10 @@ package org.jetbrains.jet.lang.resolve.java; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorParent; import org.jetbrains.jet.lang.resolve.DescriptorUtils; +import org.jetbrains.jet.lang.resolve.java.descriptor.JavaPackageFragmentDescriptor; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaFunctionResolver; public class JavaVisibilities { private JavaVisibilities() { @@ -29,7 +29,7 @@ public class JavaVisibilities { public static final Visibility PACKAGE_VISIBILITY = new Visibility("package", false) { @Override protected boolean isVisible(@NotNull DeclarationDescriptorWithVisibility what, @NotNull DeclarationDescriptor from) { - return isInSameNamespace(what, from); + return areInSamePackage(what, from); } @Override @@ -67,8 +67,8 @@ public class JavaVisibilities { // protected static function or property else { DeclarationDescriptor whatDeclarationDescriptor = what.getContainingDeclaration(); - assert whatDeclarationDescriptor instanceof NamespaceDescriptor : "Only static declarations can have protected_static visibility"; - whatClass = getClassForCorrespondingJavaNamespace((NamespaceDescriptor) whatDeclarationDescriptor); + assert whatDeclarationDescriptor instanceof JavaPackageFragmentDescriptor : "Only static declarations can have protected_static visibility"; + whatClass = JavaFunctionResolver.getClassForCorrespondingJavaPackage((JavaPackageFragmentDescriptor) whatDeclarationDescriptor); } assert whatClass != null : "Couldn't find ClassDescriptor for protected static member " + what; @@ -94,7 +94,7 @@ public class JavaVisibilities { public static final Visibility PROTECTED_AND_PACKAGE = new Visibility("protected_and_package", false) { @Override protected boolean isVisible(@NotNull DeclarationDescriptorWithVisibility what, @NotNull DeclarationDescriptor from) { - if (isInSameNamespace(what, from)) { + if (areInSamePackage(what, from)) { return true; } @@ -130,40 +130,9 @@ public class JavaVisibilities { } }; - private static boolean isInSameNamespace(@NotNull DeclarationDescriptor first, @NotNull DeclarationDescriptor second) { - NamespaceDescriptor whatPackage = DescriptorUtils.getParentOfType(first, NamespaceDescriptor.class, false); - NamespaceDescriptor fromPackage = DescriptorUtils.getParentOfType(second, NamespaceDescriptor.class, false); - return fromPackage != null && whatPackage != null && fqNamesEqual(whatPackage, fromPackage); - } - - private static boolean fqNamesEqual(@NotNull NamespaceDescriptor a, @NotNull NamespaceDescriptor b) { - return DescriptorUtils.getFQName(a).equals(DescriptorUtils.getFQName(b)); - } - - @Nullable - private static ClassDescriptor getClassForCorrespondingJavaNamespace(@NotNull NamespaceDescriptor correspondingNamespace) { - NamespaceDescriptorParent containingDeclaration = correspondingNamespace.getContainingDeclaration(); - if (!(containingDeclaration instanceof NamespaceDescriptor)) { - return null; - } - - NamespaceDescriptor namespaceDescriptor = (NamespaceDescriptor) containingDeclaration; - - ClassifierDescriptor classDescriptor = namespaceDescriptor.getMemberScope().getClassifier(correspondingNamespace.getName()); - if (classDescriptor != null && classDescriptor instanceof ClassDescriptor) { - return (ClassDescriptor) classDescriptor; - } - - ClassDescriptor classDescriptorForOuterClass = getClassForCorrespondingJavaNamespace(namespaceDescriptor); - if (classDescriptorForOuterClass == null) { - return null; - } - - ClassifierDescriptor innerClassDescriptor = - classDescriptorForOuterClass.getUnsubstitutedInnerClassesScope().getClassifier(correspondingNamespace.getName()); - if (innerClassDescriptor instanceof ClassDescriptor) { - return (ClassDescriptor) innerClassDescriptor; - } - return null; + private static boolean areInSamePackage(@NotNull DeclarationDescriptor first, @NotNull DeclarationDescriptor second) { + PackageFragmentDescriptor whatPackage = DescriptorUtils.getParentOfType(first, PackageFragmentDescriptor.class, false); + PackageFragmentDescriptor fromPackage = DescriptorUtils.getParentOfType(second, PackageFragmentDescriptor.class, false); + return fromPackage != null && whatPackage != null && whatPackage.getFqName().equals(fromPackage.getFqName()); } } diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/descriptor/JavaNamespaceDescriptor.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/descriptor/JavaNamespaceDescriptor.java deleted file mode 100644 index 4a33a3c5aa9..00000000000 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/descriptor/JavaNamespaceDescriptor.java +++ /dev/null @@ -1,53 +0,0 @@ -/* - * Copyright 2010-2013 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.descriptor; - -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.descriptors.impl.AbstractNamespaceDescriptorImpl; -import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorParent; -import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; -import org.jetbrains.jet.lang.resolve.name.FqName; -import org.jetbrains.jet.lang.resolve.scopes.JetScope; - -import java.util.List; - -public class JavaNamespaceDescriptor extends AbstractNamespaceDescriptorImpl { - private JetScope memberScope; - private final FqName qualifiedName; - - public JavaNamespaceDescriptor(NamespaceDescriptorParent containingDeclaration, List annotations, - @NotNull FqName qualifiedName) { - super(containingDeclaration, annotations, qualifiedName.shortNameOrSpecial()); - this.qualifiedName = qualifiedName; - } - - public void setMemberScope(@NotNull JetScope memberScope) { - this.memberScope = memberScope; - } - - @NotNull - @Override - public JetScope getMemberScope() { - return memberScope; - } - - @NotNull - @Override - public FqName getFqName() { - return qualifiedName; - } -} diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/descriptor/JavaPackageFragmentDescriptor.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/descriptor/JavaPackageFragmentDescriptor.java new file mode 100644 index 00000000000..936f40d5246 --- /dev/null +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/descriptor/JavaPackageFragmentDescriptor.java @@ -0,0 +1,87 @@ +/* + * Copyright 2010-2013 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.descriptor; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptorVisitor; +import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; +import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor; +import org.jetbrains.jet.lang.descriptors.impl.DeclarationDescriptorImpl; +import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorParent; +import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProvider; +import org.jetbrains.jet.lang.resolve.name.FqName; +import org.jetbrains.jet.lang.resolve.scopes.JetScope; +import org.jetbrains.jet.lang.types.TypeSubstitutor; + +import java.util.Collections; +import java.util.List; + +public class JavaPackageFragmentDescriptor extends DeclarationDescriptorImpl implements PackageFragmentDescriptor { + private final JavaPackageFragmentProvider provider; + private final FqName fqName; + private JetScope memberScope; + + public JavaPackageFragmentDescriptor( + @NotNull JavaPackageFragmentProvider provider, + @NotNull FqName fqName + ) { + super(Collections.emptyList(), fqName.shortNameOrSpecial()); + this.provider = provider; + this.fqName = fqName; + } + + @NotNull + @Override + public ModuleDescriptor getContainingDeclaration() { + return provider.getModule(); + } + + @Nullable + @Override + public DeclarationDescriptor substitute(@NotNull TypeSubstitutor substitutor) { + return this; + } + + @Override + public R accept(DeclarationDescriptorVisitor visitor, D data) { + return visitor.visitPackageFragmentDescriptor(this, data); + } + + public void setMemberScope(@NotNull JetScope memberScope) { + this.memberScope = memberScope; + } + + @NotNull + @Override + public JetScope getMemberScope() { + return memberScope; + } + + @NotNull + @Override + public FqName getFqName() { + return fqName; + } + + @NotNull + public JavaPackageFragmentProvider getProvider() { + return provider; + } +} diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java index 43dfedfa178..dd51751d9d5 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java @@ -65,7 +65,7 @@ public final class JavaClassResolver { private JavaMemberResolver memberResolver; private JavaAnnotationResolver annotationResolver; private JavaClassFinder javaClassFinder; - private JavaNamespaceResolver namespaceResolver; + private JavaPackageFragmentProvider packageFragmentProvider; private JavaSupertypeResolver supertypesResolver; private JavaFunctionResolver functionResolver; private DeserializedDescriptorResolver deserializedDescriptorResolver; @@ -105,8 +105,8 @@ public final class JavaClassResolver { } @Inject - public void setNamespaceResolver(JavaNamespaceResolver namespaceResolver) { - this.namespaceResolver = namespaceResolver; + public void setPackageFragmentProvider(JavaPackageFragmentProvider packageFragmentProvider) { + this.packageFragmentProvider = packageFragmentProvider; } @Inject @@ -385,11 +385,11 @@ public final class JavaClassResolver { } else { FqName parentFqName = childClassFQName.parent(); - NamespaceDescriptor parentNamespace = namespaceResolver.resolveNamespace(parentFqName, INCLUDE_KOTLIN_SOURCES); - if (parentNamespace == null) { + PackageFragmentDescriptor parentPackage = packageFragmentProvider.getOrCreatePackage(parentFqName); + if (parentPackage == null) { throw new IllegalStateException("Could not resolve " + parentFqName + " required to be parent for " + childClassFQName); } - return parentNamespace; + return parentPackage; } } diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java index 53f350ddf02..77240726021 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java @@ -19,15 +19,16 @@ package org.jetbrains.jet.lang.resolve.java.resolver; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorParent; import org.jetbrains.jet.lang.descriptors.impl.SimpleFunctionDescriptorImpl; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.java.descriptor.JavaClassDescriptor; import org.jetbrains.jet.lang.resolve.java.descriptor.JavaMethodDescriptor; +import org.jetbrains.jet.lang.resolve.java.descriptor.JavaPackageFragmentDescriptor; import org.jetbrains.jet.lang.resolve.java.descriptor.SamConstructorDescriptor; import org.jetbrains.jet.lang.resolve.java.scope.NamedMembers; import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod; import org.jetbrains.jet.lang.resolve.java.structure.JavaType; +import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.types.JetType; @@ -137,7 +138,7 @@ public final class JavaFunctionResolver { List superFunctions; ExternalSignatureResolver.AlternativeMethodSignature effectiveSignature; - if (ownerDescriptor instanceof NamespaceDescriptor) { + if (ownerDescriptor instanceof PackageFragmentDescriptor) { superFunctions = Collections.emptyList(); effectiveSignature = externalSignatureResolver .resolveAlternativeMethodSignature(method, false, returnType, null, valueParameters, methodTypeParameters); @@ -198,8 +199,8 @@ public final class JavaFunctionResolver { } } - if (owner instanceof NamespaceDescriptor) { - SamConstructorDescriptor samConstructor = resolveSamConstructor((NamespaceDescriptor) owner, members); + if (owner instanceof JavaPackageFragmentDescriptor) { + SamConstructorDescriptor samConstructor = resolveSamConstructor((JavaPackageFragmentDescriptor) owner, members); if (samConstructor != null) { functionsFromCurrent.add(samConstructor); } @@ -237,39 +238,63 @@ public final class JavaFunctionResolver { return null; } + // TODO 2 move to proper place // E.g. we have foo.Bar.Baz class declared in Java. It will produce the following descriptors structure: - // namespace foo + // package fragment foo // +-- class Bar // | +-- class Baz - // +-- namespace Bar - // We need to find class 'Baz' in namespace 'foo.Bar'. + // +-- package fragment Bar + // We need to find class 'Baz' in fragment 'foo.Bar'. @Nullable - private static JavaClassDescriptor findClassInNamespace(@NotNull NamespaceDescriptor namespace, @NotNull Name name) { - // First, try to find in namespace directly - JavaClassDescriptor found = findClassInScope(namespace.getMemberScope(), name); + private static JavaClassDescriptor findClassInPackage(@NotNull JavaPackageFragmentDescriptor fragment, @NotNull Name name) { + // First, try to find in fragment directly + JavaClassDescriptor found = findClassInScope(fragment.getMemberScope(), name); if (found != null) { return found; } // If unsuccessful, try to find class of the same name as current (class 'foo.Bar') - NamespaceDescriptorParent parent = namespace.getContainingDeclaration(); - if (parent instanceof NamespaceDescriptor) { - // Calling recursively, looking for 'Bar' in 'foo' - ClassDescriptor classForCurrentNamespace = findClassInNamespace((NamespaceDescriptor) parent, namespace.getName()); - if (classForCurrentNamespace == null) { - return null; - } - - // Try to find nested class 'Baz' in class 'foo.Bar' - return findClassInScope(DescriptorUtils.getStaticNestedClassesScope(classForCurrentNamespace), name); + JavaPackageFragmentDescriptor parentPackage = getParentPackage(fragment); + if (parentPackage == null) { + return null; } + + // Calling recursively, looking for 'Bar' in 'foo' + ClassDescriptor classForCurrentPackage = findClassInPackage(parentPackage, fragment.getName()); + if (classForCurrentPackage != null) { + // Try to find nested class 'Baz' in class 'foo.Bar' + return findClassInScope(DescriptorUtils.getStaticNestedClassesScope(classForCurrentPackage), name); + } + return null; } @Nullable - public static SamConstructorDescriptor resolveSamConstructor(@NotNull NamespaceDescriptor owner, @NotNull NamedMembers namedMembers) { + private static JavaPackageFragmentDescriptor getParentPackage(JavaPackageFragmentDescriptor fragment) { + FqName fqName = fragment.getFqName(); + if (fqName.isRoot()) { + return null; + } + + JavaPackageFragmentDescriptor parentPackage = fragment.getProvider().getOrCreatePackage(fqName.parent()); + assert parentPackage != null : " couldn't find parent package for " + fragment; + return parentPackage; + } + + @Nullable + public static JavaClassDescriptor getClassForCorrespondingJavaPackage(@NotNull JavaPackageFragmentDescriptor fragment) { + JavaPackageFragmentDescriptor parentPackage = getParentPackage(fragment); + if (parentPackage == null) { + return null; + } + + return findClassInPackage(parentPackage, fragment.getFqName().shortName()); + } + + @Nullable + public static SamConstructorDescriptor resolveSamConstructor(@NotNull JavaPackageFragmentDescriptor owner, @NotNull NamedMembers namedMembers) { if (namedMembers.getSamInterface() != null) { - JavaClassDescriptor klass = findClassInNamespace(owner, namedMembers.getName()); + JavaClassDescriptor klass = findClassInPackage(owner, namedMembers.getName()); if (klass != null) { return createSamConstructorFunction(owner, klass); } diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaMemberResolver.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaMemberResolver.java index b309aa9c210..46a6f2cfbf8 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaMemberResolver.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaMemberResolver.java @@ -30,7 +30,6 @@ import java.util.Set; public class JavaMemberResolver { private JavaClassResolver classResolver; - private JavaNamespaceResolver namespaceResolver; private JavaFunctionResolver functionResolver; private JavaPropertyResolver propertyResolver; private JavaConstructorResolver constructorResolver; @@ -40,11 +39,6 @@ public class JavaMemberResolver { this.classResolver = classResolver; } - @Inject - public void setNamespaceResolver(JavaNamespaceResolver namespaceResolver) { - this.namespaceResolver = namespaceResolver; - } - @Inject public void setFunctionResolver(JavaFunctionResolver functionResolver) { this.functionResolver = functionResolver; @@ -65,11 +59,6 @@ public class JavaMemberResolver { return classResolver.resolveClass(qualifiedName, searchRule); } - @Nullable - public NamespaceDescriptor resolveNamespace(@NotNull FqName qualifiedName, @NotNull DescriptorSearchRule searchRule) { - return namespaceResolver.resolveNamespace(qualifiedName, searchRule); - } - @NotNull public Set resolveFunctionGroupForClass(@NotNull NamedMembers members, @NotNull ClassOrNamespaceDescriptor owner) { return functionResolver.resolveFunctionGroupForClass(members, owner); diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaNamespaceResolver.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPackageFragmentProvider.java similarity index 53% rename from core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaNamespaceResolver.java rename to core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPackageFragmentProvider.java index 7354fb52f89..ec9757c5d05 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaNamespaceResolver.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPackageFragmentProvider.java @@ -16,17 +16,16 @@ package org.jetbrains.jet.lang.resolve.java.resolver; +import com.intellij.util.containers.ContainerUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl; -import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; -import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; -import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorParent; -import org.jetbrains.jet.lang.resolve.DescriptorUtils; -import org.jetbrains.jet.lang.resolve.java.*; -import org.jetbrains.jet.lang.resolve.java.descriptor.JavaNamespaceDescriptor; -import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap; +import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor; +import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider; +import org.jetbrains.jet.lang.resolve.java.JavaClassFinder; +import org.jetbrains.jet.lang.resolve.java.PackageClassUtils; +import org.jetbrains.jet.lang.resolve.java.descriptor.JavaPackageFragmentDescriptor; import org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils; import org.jetbrains.jet.lang.resolve.java.scope.JavaClassStaticMembersScope; import org.jetbrains.jet.lang.resolve.java.scope.JavaPackageScope; @@ -44,16 +43,9 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope; import javax.inject.Inject; import java.util.*; -import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_KOTLIN_SOURCES; - -public final class JavaNamespaceResolver { - +public final class JavaPackageFragmentProvider implements PackageFragmentProvider { @NotNull - public static final ModuleDescriptor FAKE_ROOT_MODULE = new ModuleDescriptorImpl(JavaDescriptorResolver.JAVA_ROOT, - JavaBridgeConfiguration.ALL_JAVA_IMPORTS, - JavaToKotlinClassMap.getInstance()); - @NotNull - private final Map resolvedNamespaceCache = new HashMap(); + private final Map packageFragments = new HashMap(); @NotNull private final Set unresolvedCache = new HashSet(); @@ -64,6 +56,8 @@ public final class JavaNamespaceResolver { private DeserializedDescriptorResolver deserializedDescriptorResolver; private KotlinClassFinder kotlinClassFinder; + private ModuleDescriptor module; + @Inject public void setKotlinClassFinder(KotlinClassFinder kotlinClassFinder) { this.kotlinClassFinder = kotlinClassFinder; @@ -89,65 +83,66 @@ public final class JavaNamespaceResolver { this.deserializedDescriptorResolver = deserializedDescriptorResolver; } - @Nullable - public NamespaceDescriptor resolveNamespace(@NotNull FqName qualifiedName, @NotNull DescriptorSearchRule searchRule) { - if (searchRule == INCLUDE_KOTLIN_SOURCES) { - NamespaceDescriptor kotlinNamespaceDescriptor = cache.getPackageResolvedFromSource(qualifiedName); - if (kotlinNamespaceDescriptor != null) { - return kotlinNamespaceDescriptor; - } + @Inject + public void setModule(ModuleDescriptor module) { + this.module = module; + // TODO 1 hacky + ((ModuleDescriptorImpl) module).addFragmentProvider(this); + } + + @NotNull + @Override + public List getPackageFragments(@NotNull FqName fqName) { + return ContainerUtil.createMaybeSingletonList(getOrCreatePackage(fqName)); + } + + @NotNull + @Override + public Collection getSubPackagesOf(@NotNull FqName fqName) { + PackageFragmentDescriptor packageFragment = getOrCreatePackage(fqName); + if (packageFragment == null) { + return Collections.emptyList(); } + JetScope scope = packageFragment.getMemberScope(); + // TODO 2 replace instanceof with interface + if (scope instanceof JavaPackageScope) { + return ((JavaPackageScope) scope).getSubPackages(); + } + if (scope instanceof JavaClassStaticMembersScope) { + return ((JavaClassStaticMembersScope) scope).getSubPackages(); + } + return Collections.emptyList(); + } + + @Nullable + public JavaPackageFragmentDescriptor getOrCreatePackage(@NotNull FqName qualifiedName) { + // TODO 1 use one cache if (unresolvedCache.contains(qualifiedName)) { return null; } - JetScope scope = resolvedNamespaceCache.get(qualifiedName); + JetScope scope = packageFragments.get(qualifiedName); if (scope != null) { - return (NamespaceDescriptor) scope.getContainingDeclaration(); + return (JavaPackageFragmentDescriptor) scope.getContainingDeclaration(); } - NamespaceDescriptorParent parentNs = resolveParentNamespace(qualifiedName); - if (parentNs == null) { + JavaPackageFragmentDescriptor packageFragment = new JavaPackageFragmentDescriptor(this, qualifiedName); + + JetScope namespaceScope = createPackageScope(qualifiedName, packageFragment, true); + cache(qualifiedName, namespaceScope); + if (namespaceScope == null) { return null; } - JavaNamespaceDescriptor javaNamespaceDescriptor = new JavaNamespaceDescriptor( - parentNs, - Collections.emptyList(), // TODO - qualifiedName - ); + packageFragment.setMemberScope(namespaceScope); - JetScope newScope = createNamespaceScope(qualifiedName, javaNamespaceDescriptor, true); - if (newScope == null) { - return null; - } - - javaNamespaceDescriptor.setMemberScope(newScope); - - return javaNamespaceDescriptor; + return packageFragment; } @Nullable - private NamespaceDescriptorParent resolveParentNamespace(@NotNull FqName fqName) { - if (fqName.isRoot()) { - return FAKE_ROOT_MODULE; - } - else { - return resolveNamespace(fqName.parent(), INCLUDE_KOTLIN_SOURCES); - } - } - - @Nullable - private JetScope createNamespaceScope(@NotNull FqName fqName, @NotNull NamespaceDescriptor namespaceDescriptor, boolean record) { - JetScope namespaceScope = doCreateNamespaceScope(fqName, namespaceDescriptor, record); - cache(fqName, namespaceScope); - return namespaceScope; - } - - @Nullable - private JetScope doCreateNamespaceScope( + private JetScope createPackageScope( @NotNull FqName fqName, - @NotNull NamespaceDescriptor namespaceDescriptor, + @NotNull PackageFragmentDescriptor packageFragment, boolean record ) { JavaPackage javaPackage = javaClassFinder.findPackage(fqName); @@ -155,43 +150,29 @@ public final class JavaNamespaceResolver { FqName packageClassFqName = PackageClassUtils.getPackageClassFqName(fqName); KotlinJvmBinaryClass kotlinClass = kotlinClassFinder.find(packageClassFqName); - cache.recordProperNamespace(namespaceDescriptor); + cache.recordProperPackage(packageFragment); if (kotlinClass != null) { - JetScope kotlinPackageScope = deserializedDescriptorResolver.createKotlinPackageScope(namespaceDescriptor, kotlinClass); + JetScope kotlinPackageScope = deserializedDescriptorResolver.createKotlinPackageScope(packageFragment, kotlinClass); if (kotlinPackageScope != null) { return kotlinPackageScope; } } - - // Otherwise (if psiClass is null or doesn't have a supported Kotlin annotation), it's a Java class and the package is empty - if (record) { - cache.recordPackage(javaPackage, namespaceDescriptor); - } - - return new JavaPackageScope(namespaceDescriptor, javaPackage, fqName, memberResolver); + return new JavaPackageScope(packageFragment, javaPackage, fqName, memberResolver); } JavaClass javaClass = javaClassFinder.findClass(fqName); - if (javaClass == null) { - return null; + if (javaClass != null && shouldCreateStaticMembersPackage(javaClass)) { + cache.recordClassStaticMembersNamespace(packageFragment); + return new JavaClassStaticMembersScope(packageFragment, javaClass, memberResolver); } + return null; + } - if (DescriptorResolverUtils.isCompiledKotlinClassOrPackageClass(javaClass)) { - return null; - } - if (!hasStaticMembers(javaClass)) { - return null; - } - - cache.recordClassStaticMembersNamespace(namespaceDescriptor); - - if (record) { - cache.recordPackage(javaClass, namespaceDescriptor); - } - - return new JavaClassStaticMembersScope(namespaceDescriptor, fqName, javaClass, memberResolver); + // TODO 2 move to more decent place + public static boolean shouldCreateStaticMembersPackage(@NotNull JavaClass javaClass) { + return !DescriptorResolverUtils.isCompiledKotlinClassOrPackageClass(javaClass) && hasStaticMembers(javaClass); } private void cache(@NotNull FqName fqName, @Nullable JetScope packageScope) { @@ -199,27 +180,12 @@ public final class JavaNamespaceResolver { unresolvedCache.add(fqName); return; } - JetScope oldValue = resolvedNamespaceCache.put(fqName, packageScope); + JetScope oldValue = packageFragments.put(fqName, packageScope); if (oldValue != null) { throw new IllegalStateException("rewrite at " + fqName); } } - @Nullable - public JetScope getJavaPackageScopeForExistingNamespaceDescriptor(@NotNull NamespaceDescriptor namespaceDescriptor) { - FqName fqName = DescriptorUtils.getFQName(namespaceDescriptor).toSafe(); - if (unresolvedCache.contains(fqName)) { - throw new IllegalStateException( - "This means that we are trying to create a Java package, but have a package with the same FQN defined in Kotlin: " + - fqName); - } - JetScope alreadyResolvedScope = resolvedNamespaceCache.get(fqName); - if (alreadyResolvedScope != null) { - return alreadyResolvedScope; - } - return createNamespaceScope(fqName, namespaceDescriptor, false); - } - private static boolean hasStaticMembers(@NotNull JavaClass javaClass) { for (JavaMethod method : javaClass.getMethods()) { if (method.isStatic() && !DescriptorResolverUtils.shouldBeInEnumClassObject(method)) { @@ -260,4 +226,9 @@ public final class JavaNamespaceResolver { return result; } + + @NotNull + public ModuleDescriptor getModule() { + return module; + } } diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaResolverCache.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaResolverCache.java index 470fcc14532..7d0f8788b34 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaResolverCache.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaResolverCache.java @@ -29,9 +29,6 @@ public interface JavaResolverCache { @Nullable ClassDescriptor getClassResolvedFromSource(@NotNull FqName fqName); - @Nullable - NamespaceDescriptor getPackageResolvedFromSource(@NotNull FqName fqName); - @Nullable SimpleFunctionDescriptor getMethod(@NotNull JavaMethod method); @@ -49,9 +46,7 @@ public interface JavaResolverCache { void recordClass(@NotNull JavaClass javaClass, @NotNull ClassDescriptor descriptor); - void recordProperNamespace(@NotNull NamespaceDescriptor descriptor); + void recordProperPackage(@NotNull PackageFragmentDescriptor descriptor); - void recordClassStaticMembersNamespace(@NotNull NamespaceDescriptor descriptor); - - void recordPackage(@NotNull JavaElement element, @NotNull NamespaceDescriptor descriptor); + void recordClassStaticMembersNamespace(@NotNull PackageFragmentDescriptor descriptor); } diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassStaticMembersScope.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassStaticMembersScope.java index ef4aff7523d..a5a850d197e 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassStaticMembersScope.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaClassStaticMembersScope.java @@ -16,58 +16,47 @@ package org.jetbrains.jet.lang.resolve.java.scope; +import com.google.common.collect.Lists; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor; import org.jetbrains.jet.lang.resolve.java.resolver.JavaMemberResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProvider; import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; import org.jetbrains.jet.lang.resolve.name.FqName; -import org.jetbrains.jet.lang.resolve.name.Name; import java.util.Collection; import java.util.Collections; - -import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_KOTLIN_SOURCES; +import java.util.List; public final class JavaClassStaticMembersScope extends JavaClassMembersScope { - @NotNull - private final FqName packageFQN; @NotNull private final JavaClass javaClass; public JavaClassStaticMembersScope( - @NotNull NamespaceDescriptor descriptor, - @NotNull FqName packageFQN, + @NotNull PackageFragmentDescriptor descriptor, @NotNull JavaClass javaClass, @NotNull JavaMemberResolver memberResolver ) { super(descriptor, MembersProvider.forClass(javaClass, true), memberResolver); - this.packageFQN = packageFQN; this.javaClass = javaClass; } - @Override - public NamespaceDescriptor getNamespace(@NotNull Name name) { - return memberResolver.resolveNamespace(packageFQN.child(name), INCLUDE_KOTLIN_SOURCES); - } - - @NotNull - @Override - protected Collection computeAllDescriptors() { - Collection result = super.computeAllDescriptors(); - for (JavaClass nested : javaClass.getInnerClasses()) { - NamespaceDescriptor namespace = getNamespace(nested.getName()); - if (namespace != null) { - result.add(namespace); - } - } - return result; - } - @NotNull @Override protected Collection computeInnerClasses() { return Collections.emptyList(); } + + @NotNull + public Collection getSubPackages() { + List result = Lists.newArrayList(); + for (JavaClass nested : javaClass.getInnerClasses()) { + if (JavaPackageFragmentProvider.shouldCreateStaticMembersPackage(nested)) { + result.add(nested.getFqName()); + } + } + return result; + } + } diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaPackageScope.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaPackageScope.java index 74133f6ecae..ef1e8427d37 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaPackageScope.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/scope/JavaPackageScope.java @@ -16,25 +16,20 @@ package org.jetbrains.jet.lang.resolve.java.scope; +import com.google.common.collect.Lists; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.*; +import org.jetbrains.jet.lang.resolve.java.descriptor.JavaPackageFragmentDescriptor; import org.jetbrains.jet.lang.resolve.java.descriptor.SamConstructorDescriptor; -import org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaFunctionResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaMemberResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.ProgressChecker; +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.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; -import java.util.Collection; -import java.util.Collections; -import java.util.HashSet; -import java.util.Set; +import java.util.*; import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.IGNORE_KOTLIN_SOURCES; -import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_KOTLIN_SOURCES; public final class JavaPackageScope extends JavaBaseScope { @NotNull @@ -43,7 +38,7 @@ public final class JavaPackageScope extends JavaBaseScope { private final FqName packageFQN; public JavaPackageScope( - @NotNull NamespaceDescriptor descriptor, + @NotNull PackageFragmentDescriptor descriptor, @NotNull JavaPackage javaPackage, @NotNull FqName packageFQN, @NotNull JavaMemberResolver memberResolver @@ -58,11 +53,6 @@ public final class JavaPackageScope extends JavaBaseScope { return memberResolver.resolveClass(packageFQN.child(name), IGNORE_KOTLIN_SOURCES); } - @Override - public NamespaceDescriptor getNamespace(@NotNull Name name) { - return memberResolver.resolveNamespace(packageFQN.child(name), INCLUDE_KOTLIN_SOURCES); - } - @NotNull @Override protected Collection computeAllDescriptors() { @@ -75,13 +65,6 @@ public final class JavaPackageScope extends JavaBaseScope { private Collection computeAllPackageDeclarations() { Collection result = new HashSet(); - for (JavaPackage subPackage : javaPackage.getSubPackages()) { - NamespaceDescriptor childNs = memberResolver.resolveNamespace(subPackage.getFqName(), IGNORE_KOTLIN_SOURCES); - if (childNs != null) { - result.add(childNs); - } - } - for (JavaClass javaClass : DescriptorResolverUtils.getClassesInPackage(javaPackage)) { if (DescriptorResolverUtils.isCompiledKotlinPackageClass(javaClass)) continue; @@ -98,11 +81,6 @@ public final class JavaPackageScope extends JavaBaseScope { if (classDescriptor != null) { result.add(classDescriptor); } - - NamespaceDescriptor namespace = memberResolver.resolveNamespace(fqName, IGNORE_KOTLIN_SOURCES); - if (namespace != null) { - result.add(namespace); - } } return result; @@ -115,7 +93,7 @@ public final class JavaPackageScope extends JavaBaseScope { if (members == null) { return Collections.emptySet(); } - SamConstructorDescriptor samConstructor = JavaFunctionResolver.resolveSamConstructor((NamespaceDescriptor) descriptor, members); + SamConstructorDescriptor samConstructor = JavaFunctionResolver.resolveSamConstructor((JavaPackageFragmentDescriptor) descriptor, members); if (samConstructor == null) { return Collections.emptySet(); } @@ -127,4 +105,18 @@ public final class JavaPackageScope extends JavaBaseScope { protected Collection computeInnerClasses() { return Collections.emptyList(); } + + @NotNull + public Collection getSubPackages() { + List result = Lists.newArrayList(); + for (JavaPackage subPackage : javaPackage.getSubPackages()) { + result.add(subPackage.getFqName()); + } + for (JavaClass javaClass : DescriptorResolverUtils.getClassesInPackage(javaPackage)) { + if (JavaPackageFragmentProvider.shouldCreateStaticMembersPackage(javaClass)) { + result.add(javaClass.getFqName()); + } + } + return result; + } } diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorDeserializer.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorDeserializer.java index 6496ba4fb7f..9088b36da3f 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorDeserializer.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorDeserializer.java @@ -114,8 +114,8 @@ public class AnnotationDescriptorDeserializer implements AnnotationDeserializer if (descriptor instanceof ClassDescriptor) { return kotlinClassFinder.find(kotlinFqNameToJavaFqName(naiveKotlinFqName((ClassDescriptor) descriptor))); } - else if (descriptor instanceof NamespaceDescriptor) { - return kotlinClassFinder.find(PackageClassUtils.getPackageClassFqName(DescriptorUtils.getFQName(descriptor).toSafe())); + else if (descriptor instanceof PackageFragmentDescriptor) { + return kotlinClassFinder.find(PackageClassUtils.getPackageClassFqName(((PackageFragmentDescriptor) descriptor).getFqName())); } else { throw new IllegalStateException("Unrecognized descriptor: " + descriptor); @@ -253,15 +253,15 @@ public class AnnotationDescriptorDeserializer implements AnnotationDeserializer @NotNull NameResolver nameResolver, @NotNull AnnotatedCallableKind kind ) { - if (container instanceof NamespaceDescriptor) { - return loadPackageFragmentClassFqName((NamespaceDescriptor) container, proto, nameResolver); + if (container instanceof PackageFragmentDescriptor) { + return loadPackageFragmentClassFqName((PackageFragmentDescriptor) container, proto, nameResolver); } else if (isClassObject(container) && isStaticFieldInOuter(proto)) { // Backing fields of properties of a class object are generated in the outer class return findKotlinClassByDescriptor((ClassOrNamespaceDescriptor) container.getContainingDeclaration()); } else if (isTrait(container) && kind == AnnotatedCallableKind.PROPERTY) { - NamespaceDescriptor containingPackage = DescriptorUtils.getParentOfType(container, NamespaceDescriptor.class); + PackageFragmentDescriptor containingPackage = DescriptorUtils.getParentOfType(container, PackageFragmentDescriptor.class); assert containingPackage != null : "Trait must have a namespace among his parents: " + container; if (proto.hasExtension(JavaProtoBuf.implClassName)) { @@ -276,7 +276,7 @@ public class AnnotationDescriptorDeserializer implements AnnotationDeserializer @Nullable private KotlinJvmBinaryClass loadPackageFragmentClassFqName( - @NotNull NamespaceDescriptor container, + @NotNull PackageFragmentDescriptor container, @NotNull ProtoBuf.Callable proto, @NotNull NameResolver nameResolver ) { diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DeserializedDescriptorResolver.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DeserializedDescriptorResolver.java index 142fee4678c..e27de9fed33 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DeserializedDescriptorResolver.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DeserializedDescriptorResolver.java @@ -25,10 +25,10 @@ import org.jetbrains.jet.descriptors.serialization.JavaProtoBufUtil; import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedClassDescriptor; import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedPackageMemberScope; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor; import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter; import org.jetbrains.jet.lang.resolve.java.resolver.JavaClassResolver; -import org.jetbrains.jet.lang.resolve.java.resolver.JavaNamespaceResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaPackageFragmentProvider; import org.jetbrains.jet.lang.resolve.kotlin.header.KotlinClassHeader; import org.jetbrains.jet.lang.resolve.kotlin.header.SerializedDataHeader; import org.jetbrains.jet.lang.resolve.name.FqName; @@ -39,7 +39,6 @@ import org.jetbrains.jet.storage.LockBasedStorageManager; import javax.inject.Inject; import java.util.Collection; -import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.IGNORE_KOTLIN_SOURCES; import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_KOTLIN_SOURCES; import static org.jetbrains.jet.lang.resolve.kotlin.DeserializedResolverUtils.kotlinFqNameToJavaFqName; @@ -48,7 +47,7 @@ public final class DeserializedDescriptorResolver { private final LockBasedStorageManager storageManager = new LockBasedStorageManager(); - private JavaNamespaceResolver javaNamespaceResolver; + private JavaPackageFragmentProvider javaPackageFragmentProvider; private JavaClassResolver javaClassResolver; @@ -64,14 +63,14 @@ public final class DeserializedDescriptorResolver { @Nullable @Override - public NamespaceDescriptor findPackage(@NotNull FqName name) { - return javaNamespaceResolver.resolveNamespace(name, IGNORE_KOTLIN_SOURCES); + public PackageFragmentDescriptor findPackage(@NotNull FqName name) { + return javaPackageFragmentProvider.getOrCreatePackage(name); } @NotNull @Override public Collection getClassNames(@NotNull FqName packageName) { - return javaNamespaceResolver.getClassNamesInPackage(packageName); + return javaPackageFragmentProvider.getClassNamesInPackage(packageName); } }; @@ -81,8 +80,8 @@ public final class DeserializedDescriptorResolver { } @Inject - public void setJavaNamespaceResolver(JavaNamespaceResolver javaNamespaceResolver) { - this.javaNamespaceResolver = javaNamespaceResolver; + public void setJavaPackageFragmentProvider(JavaPackageFragmentProvider javaPackageFragmentProvider) { + this.javaPackageFragmentProvider = javaPackageFragmentProvider; } @Inject @@ -107,7 +106,7 @@ public final class DeserializedDescriptorResolver { } @Nullable - public JetScope createKotlinPackageScope(@NotNull NamespaceDescriptor descriptor, @NotNull KotlinJvmBinaryClass kotlinClass) { + public JetScope createKotlinPackageScope(@NotNull PackageFragmentDescriptor descriptor, @NotNull KotlinJvmBinaryClass kotlinClass) { String[] data = readData(kotlinClass); if (data != null) { return new DeserializedPackageMemberScope(storageManager, descriptor, annotationDeserializer, javaDescriptorFinder, diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DeserializedResolverUtils.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DeserializedResolverUtils.java index aa1120105ea..4c150d9a3d0 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DeserializedResolverUtils.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/DeserializedResolverUtils.java @@ -19,8 +19,7 @@ package org.jetbrains.jet.lang.resolve.kotlin; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; -import org.jetbrains.jet.lang.resolve.DescriptorUtils; +import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor; import org.jetbrains.jet.lang.resolve.java.JvmAbi; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; @@ -51,8 +50,8 @@ public class DeserializedResolverUtils { if (containing instanceof ClassDescriptor) { return naiveKotlinFqName((ClassDescriptor) containing).child(descriptor.getName()); } - else if (containing instanceof NamespaceDescriptor) { - return DescriptorUtils.getFQName(containing).child(descriptor.getName()); + else if (containing instanceof PackageFragmentDescriptor) { + return ((PackageFragmentDescriptor) containing).getFqName().child(descriptor.getName()).toUnsafe(); } else { throw new IllegalArgumentException("Class doesn't have a FQ name: " + descriptor); diff --git a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptor.java b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptor.java index 68a54f1b5de..219169ee0a5 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptor.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptor.java @@ -32,8 +32,11 @@ public interface ModuleDescriptor extends DeclarationDescriptor, NamespaceDescri @Nullable DeclarationDescriptor getContainingDeclaration(); + @NotNull + PackageFragmentProvider getPackageFragmentProvider(); + @Nullable - NamespaceDescriptor getNamespace(@NotNull FqName fqName); + PackageViewDescriptor getPackage(@NotNull FqName fqName); @NotNull ModuleConfiguration getModuleConfiguration(); diff --git a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptorImpl.java b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptorImpl.java index b08b024ddf1..b01288474be 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptorImpl.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/ModuleDescriptorImpl.java @@ -16,13 +16,15 @@ package org.jetbrains.jet.lang.descriptors; +import com.google.common.collect.Lists; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; +import org.jetbrains.jet.lang.descriptors.impl.CompositePackageFragmentProvider; import org.jetbrains.jet.lang.descriptors.impl.DeclarationDescriptorImpl; -import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorImpl; +import org.jetbrains.jet.lang.descriptors.impl.PackageViewDescriptorImpl; import org.jetbrains.jet.lang.resolve.ImportPath; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; @@ -32,7 +34,8 @@ import java.util.Collections; import java.util.List; public class ModuleDescriptorImpl extends DeclarationDescriptorImpl implements ModuleDescriptor { - private NamespaceDescriptor rootNamepsace; + private final List fragmentProviders = Lists.newArrayList(); + private final CompositePackageFragmentProvider packageFragmentProvider = new CompositePackageFragmentProvider(fragmentProviders); private ModuleConfiguration moduleConfiguration; private final List defaultImports; private final PlatformToKotlinClassMap platformToKotlinClassMap; @@ -50,11 +53,8 @@ public class ModuleDescriptorImpl extends DeclarationDescriptorImpl implements M this.platformToKotlinClassMap = platformToKotlinClassMap; } - public void setRootNamespace(@NotNull NamespaceDescriptor rootNs) { - if (this.rootNamepsace != null) { - throw new IllegalStateException("setRootNamespace() is called twice"); - } - this.rootNamepsace = rootNs; + public void addFragmentProvider(@NotNull PackageFragmentProvider provider) { + fragmentProviders.add(provider); } @Override @@ -63,16 +63,19 @@ public class ModuleDescriptorImpl extends DeclarationDescriptorImpl implements M return null; } + @NotNull + @Override + public PackageFragmentProvider getPackageFragmentProvider() { + return packageFragmentProvider; + } + @Nullable @Override - public NamespaceDescriptor getNamespace(@NotNull FqName fqName) { - if (fqName.isRoot()) return rootNamepsace; - NamespaceDescriptor current = rootNamepsace; - for (Name simpleName : fqName.pathSegments()) { - current = current.getMemberScope().getNamespace(simpleName); - if (current == null) return null; - } - return current; + public PackageViewDescriptor getPackage(@NotNull FqName fqName) { + List fragments = packageFragmentProvider.getPackageFragments(fqName); + return !fragments.isEmpty() + ? new PackageViewDescriptorImpl(this, fqName, fragments) + : null; } @NotNull @@ -100,10 +103,6 @@ public class ModuleDescriptorImpl extends DeclarationDescriptorImpl implements M return platformToKotlinClassMap; } - public NamespaceDescriptorImpl getRootNamespaceDescriptorImpl() { - return (NamespaceDescriptorImpl) rootNamepsace; - } - @NotNull @Override public ModuleDescriptor substitute(@NotNull TypeSubstitutor substitutor) { @@ -114,14 +113,4 @@ public class ModuleDescriptorImpl extends DeclarationDescriptorImpl implements M public R accept(DeclarationDescriptorVisitor visitor, D data) { return visitor.visitModuleDeclaration(this, data); } - - - @Override - public void addNamespace(@NotNull NamespaceDescriptor namespaceDescriptor) { - if (namespaceDescriptor.getContainingDeclaration() != this) { - throw new IllegalStateException(); - } - setRootNamespace(namespaceDescriptor); - } - } diff --git a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/PackageFragmentProvider.java b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/PackageFragmentProvider.java new file mode 100644 index 00000000000..626547233d5 --- /dev/null +++ b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/PackageFragmentProvider.java @@ -0,0 +1,34 @@ +/* + * Copyright 2010-2013 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.descriptors; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.resolve.name.FqName; + +import java.util.Collection; +import java.util.List; + +public interface PackageFragmentProvider { + @NotNull + List getPackageFragments(@NotNull FqName fqName); + + /** + * @return declared subpackages of {@code fqName} + */ + @NotNull + Collection getSubPackagesOf(@NotNull FqName fqName); +} diff --git a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/PackageViewDescriptor.java b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/PackageViewDescriptor.java index 830a181642a..f8034065d95 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/PackageViewDescriptor.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/PackageViewDescriptor.java @@ -31,4 +31,7 @@ public interface PackageViewDescriptor extends DeclarationDescriptor { @NotNull JetScope getMemberScope(); + + @NotNull + ModuleDescriptor getModule(); } diff --git a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/Visibilities.java b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/Visibilities.java index ceb9c7c2e48..a77d8df5511 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/Visibilities.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/Visibilities.java @@ -33,15 +33,22 @@ public class Visibilities { while (parent != null) { parent = parent.getContainingDeclaration(); if ((parent instanceof ClassDescriptor && !DescriptorUtils.isClassObject(parent)) || - parent instanceof NamespaceDescriptor) { + parent instanceof PackageFragmentDescriptor) { break; } } + if (parent == null) { + return false; + } DeclarationDescriptor fromParent = from; while (fromParent != null) { if (parent == fromParent) { return true; } + if (fromParent instanceof PackageFragmentDescriptor) { + return parent instanceof PackageFragmentDescriptor && ((PackageFragmentDescriptor) parent).getFqName() + .isAncestorOf(((PackageFragmentDescriptor) fromParent).getFqName()); + } fromParent = fromParent.getContainingDeclaration(); } return false; @@ -112,6 +119,9 @@ public class Visibilities { @Nullable DeclarationDescriptorWithVisibility what, @NotNull DeclarationDescriptor from ) { + if (from instanceof PackageViewDescriptor) { + return null; // TODO 1 review: everything is visible from package view + } DeclarationDescriptorWithVisibility parent = what; while (parent != null && parent.getVisibility() != LOCAL) { if (!parent.getVisibility().isVisible(parent, from)) { diff --git a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/AbstractNamespaceDescriptorImpl.java b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/AbstractNamespaceDescriptorImpl.java index f96901fc200..3abadaf17ae 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/AbstractNamespaceDescriptorImpl.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/AbstractNamespaceDescriptorImpl.java @@ -46,11 +46,6 @@ public abstract class AbstractNamespaceDescriptorImpl extends DeclarationDescrip return (NamespaceDescriptorParent) super.getContainingDeclaration(); } - @Override - public void addNamespace(@NotNull NamespaceDescriptor namespaceDescriptor) { - throw new IllegalStateException("immutable"); - } - @NotNull @Override public NamespaceDescriptor substitute(@NotNull TypeSubstitutor substitutor) { diff --git a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/CompositePackageFragmentProvider.java b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/CompositePackageFragmentProvider.java new file mode 100644 index 00000000000..85757a21263 --- /dev/null +++ b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/CompositePackageFragmentProvider.java @@ -0,0 +1,57 @@ +/* + * Copyright 2010-2013 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.descriptors.impl; + +import com.google.common.collect.Lists; +import com.google.common.collect.Sets; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor; +import org.jetbrains.jet.lang.descriptors.PackageFragmentProvider; +import org.jetbrains.jet.lang.resolve.name.FqName; + +import java.util.Collection; +import java.util.List; +import java.util.Set; + +public class CompositePackageFragmentProvider implements PackageFragmentProvider { + // can be modified from outside + private final List providers; + + public CompositePackageFragmentProvider(@NotNull List providers) { + this.providers = providers; + } + + @NotNull + @Override + public List getPackageFragments(@NotNull FqName fqName) { + List result = Lists.newArrayList(); + for (PackageFragmentProvider provider : providers) { + result.addAll(provider.getPackageFragments(fqName)); + } + return result; + } + + @NotNull + @Override + public Collection getSubPackagesOf(@NotNull FqName fqName) { + Set result = Sets.newHashSet(); + for (PackageFragmentProvider provider : providers) { + result.addAll(provider.getSubPackagesOf(fqName)); + } + return result; + } +} diff --git a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/MutablePackageFragmentDescriptor.java b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/MutablePackageFragmentDescriptor.java new file mode 100644 index 00000000000..b6d690adff2 --- /dev/null +++ b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/MutablePackageFragmentDescriptor.java @@ -0,0 +1,96 @@ +/* + * Copyright 2010-2013 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.descriptors.impl; + +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; +import org.jetbrains.jet.lang.descriptors.DeclarationDescriptorVisitor; +import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; +import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor; +import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; +import org.jetbrains.jet.lang.resolve.name.FqName; +import org.jetbrains.jet.lang.resolve.scopes.JetScope; +import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler; +import org.jetbrains.jet.lang.resolve.scopes.WritableScope; +import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl; +import org.jetbrains.jet.lang.types.TypeSubstitutor; + +import java.util.Collections; + +public class MutablePackageFragmentDescriptor extends DeclarationDescriptorImpl implements PackageFragmentDescriptor { + + private final ModuleDescriptor module; + private final FqName fqName; + private final WritableScope scope; + private final NamespaceLikeBuilder builder; + + public MutablePackageFragmentDescriptor( + @NotNull ModuleDescriptor module, + @NotNull FqName fqName + ) { + super(Collections.emptyList(), fqName.shortNameOrSpecial()); + this.module = module; + this.fqName = fqName; + + scope = new WritableScopeImpl(JetScope.EMPTY, this, RedeclarationHandler.DO_NOTHING, + "Members of " + fqName + " in " + module); + + // TODO 1 make read-only after + scope.changeLockLevel(WritableScope.LockLevel.BOTH); + builder = new ScopeBasedNamespaceLikeBuilder(this, scope); + } + + @NotNull + @Override + public ModuleDescriptor getContainingDeclaration() { + return module; + } + + @NotNull + @Override + public FqName getFqName() { + return fqName; + } + + @NotNull + @Override + public WritableScope getMemberScope() { + return scope; + } + + @Nullable + @Override + public DeclarationDescriptor substitute(@NotNull TypeSubstitutor substitutor) { + return this; + } + + @Override + public R accept(DeclarationDescriptorVisitor visitor, D data) { + return visitor.visitPackageFragmentDescriptor(this, data); + } + + @NotNull + public NamespaceLikeBuilder getBuilder() { + return builder; + } + + @Override + public String toString() { + return "fragment of " + fqName + " in " + module; + } +} diff --git a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/NamespaceDescriptorImpl.java b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/NamespaceDescriptorImpl.java index 89350b3f172..e23a98c03f5 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/NamespaceDescriptorImpl.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/NamespaceDescriptorImpl.java @@ -25,6 +25,7 @@ import org.jetbrains.jet.lang.resolve.scopes.WritableScope; import java.util.List; +@Deprecated public class NamespaceDescriptorImpl extends AbstractNamespaceDescriptorImpl { private WritableScope memberScope; diff --git a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/NamespaceDescriptorParent.java b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/NamespaceDescriptorParent.java index f2b4ed0e6ab..a41febc9065 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/NamespaceDescriptorParent.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/NamespaceDescriptorParent.java @@ -16,12 +16,10 @@ package org.jetbrains.jet.lang.descriptors.impl; -import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +// TODO 2 remove +@Deprecated public interface NamespaceDescriptorParent extends DeclarationDescriptor { - void addNamespace(@NotNull NamespaceDescriptor namespaceDescriptor); - } diff --git a/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/PackageViewDescriptorImpl.java b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/PackageViewDescriptorImpl.java new file mode 100644 index 00000000000..8a5306f99e9 --- /dev/null +++ b/core/descriptors/src/org/jetbrains/jet/lang/descriptors/impl/PackageViewDescriptorImpl.java @@ -0,0 +1,155 @@ +/* + * Copyright 2010-2013 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.descriptors.impl; + +import com.google.common.collect.Lists; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.lang.descriptors.*; +import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; +import org.jetbrains.jet.lang.resolve.name.FqName; +import org.jetbrains.jet.lang.resolve.name.Name; +import org.jetbrains.jet.lang.resolve.scopes.ChainedScope; +import org.jetbrains.jet.lang.resolve.scopes.JetScope; +import org.jetbrains.jet.lang.resolve.scopes.JetScopeImpl; +import org.jetbrains.jet.lang.types.TypeSubstitutor; +import org.jetbrains.jet.utils.Printer; + +import java.util.Collection; +import java.util.Collections; +import java.util.List; + +public class PackageViewDescriptorImpl extends DeclarationDescriptorImpl implements PackageViewDescriptor { + private final ModuleDescriptor module; + private final FqName fqName; + private final JetScope memberScope; + + public PackageViewDescriptorImpl( + @NotNull ModuleDescriptor module, + @NotNull FqName fqName, + @NotNull List fragments + ) { + super(Collections.emptyList(), fqName.shortNameOrSpecial()); + this.module = module; + this.fqName = fqName; + + List scopes = Lists.newArrayList(); + assert !fragments.isEmpty() : fqName + " in " + module; + for (PackageFragmentDescriptor fragment : fragments) { + scopes.add(fragment.getMemberScope()); + } + scopes.add(new SubpackagesScope()); + + memberScope = new ChainedScope(this, "package view scope for " + fqName + " in " + module.getName(), + scopes.toArray(new JetScope[scopes.size()])); + } + + @Nullable + @Override + public PackageViewDescriptor getContainingDeclaration() { + return fqName.isRoot() ? null : module.getPackage(fqName.parent()); + } + + @Nullable + @Override + public DeclarationDescriptor substitute(@NotNull TypeSubstitutor substitutor) { + return this; + } + + @Override + public R accept(DeclarationDescriptorVisitor visitor, D data) { + return visitor.visitPackageViewDescriptor(this, data); + } + + @NotNull + @Override + public FqName getFqName() { + return fqName; + } + + @NotNull + @Override + public JetScope getMemberScope() { + return memberScope; + } + + @Override + @NotNull + public ModuleDescriptor getModule() { + return module; + } + + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + + PackageViewDescriptorImpl that = (PackageViewDescriptorImpl) o; + + if (!fqName.equals(that.fqName)) return false; + if (!module.equals(that.module)) return false; + + return true; + } + + + @Override + public int hashCode() { + int result = module.hashCode(); + result = 31 * result + fqName.hashCode(); + return result; + } + + @Override + public String toString() { + return DescriptorRenderer.DEBUG_TEXT.render(this); + } + + private class SubpackagesScope extends JetScopeImpl { + @NotNull + @Override + public DeclarationDescriptor getContainingDeclaration() { + return PackageViewDescriptorImpl.this; + } + + @Nullable + @Override + public PackageViewDescriptor getPackage(@NotNull Name name) { + return name.isSpecial() ? null : module.getPackage(fqName.child(name)); + } + + @NotNull + @Override + public Collection getAllDescriptors() { + List result = Lists.newArrayList(); + for (FqName subFqName : module.getPackageFragmentProvider().getSubPackagesOf(fqName)) { + result.add(getPackage(subFqName.shortName())); + } + return result; + } + + @Override + public void printScopeStructure(@NotNull Printer p) { + p.println(getClass().getSimpleName(), " {"); + p.pushIndent(); + + p.println("thisDescriptor = ", PackageViewDescriptorImpl.this); + + p.popIndent(); + p.println("}"); + } + } +} diff --git a/core/descriptors/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java b/core/descriptors/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java index b3e22ef0272..e2701723725 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java @@ -111,21 +111,15 @@ public class DescriptorUtils { public static FqNameUnsafe getFQName(@NotNull DeclarationDescriptor descriptor) { DeclarationDescriptor containingDeclaration = descriptor.getContainingDeclaration(); - if (descriptor instanceof ModuleDescriptor || containingDeclaration instanceof ModuleDescriptor) { + if (descriptor instanceof ModuleDescriptor || ErrorUtils.isError(descriptor)) { return FqName.ROOT.toUnsafe(); } - if (containingDeclaration == null) { - if (descriptor instanceof NamespaceDescriptor) { - // TODO: namespace must always have parent - if (descriptor.getName().equals(Name.identifier("jet"))) { - return FqNameUnsafe.topLevel(Name.identifier("jet")); - } - if (descriptor.getName().equals(Name.special(""))) { - return FqName.ROOT.toUnsafe(); - } - } - throw new IllegalStateException("descriptor is not module descriptor and has null containingDeclaration: " + descriptor); + if (descriptor instanceof PackageViewDescriptor) { + return ((PackageViewDescriptor) descriptor).getFqName().toUnsafe(); + } + else if (descriptor instanceof PackageFragmentDescriptor) { + return ((PackageFragmentDescriptor) descriptor).getFqName().toUnsafe(); } if (containingDeclaration instanceof ClassDescriptor && ((ClassDescriptor) containingDeclaration).getKind() == ClassKind.CLASS_OBJECT) { @@ -138,7 +132,7 @@ public class DescriptorUtils { } public static boolean isTopLevelDeclaration(@NotNull DeclarationDescriptor descriptor) { - return descriptor.getContainingDeclaration() instanceof NamespaceDescriptor; + return descriptor.getContainingDeclaration() instanceof PackageFragmentDescriptor; } public static boolean isInSameModule(@NotNull DeclarationDescriptor first, @NotNull DeclarationDescriptor second) { @@ -303,7 +297,7 @@ public class DescriptorUtils { public static boolean inStaticContext(@NotNull DeclarationDescriptor descriptor) { DeclarationDescriptor containingDeclaration = descriptor.getContainingDeclaration(); - if (containingDeclaration instanceof NamespaceDescriptor) { + if (containingDeclaration instanceof PackageFragmentDescriptor) { return true; } if (containingDeclaration instanceof ClassDescriptor) { diff --git a/core/descriptors/src/org/jetbrains/jet/lang/resolve/name/FqName.java b/core/descriptors/src/org/jetbrains/jet/lang/resolve/name/FqName.java index bf351a1ba77..81cf8190815 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/resolve/name/FqName.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/resolve/name/FqName.java @@ -141,6 +141,11 @@ public final class FqName extends FqNameBase { return fqName.lastSegmentIs(segment); } + public boolean isAncestorOf(@NotNull FqName other) { + String thisString = this.asString(); + String otherString = other.asString(); + return otherString.equals(thisString) || otherString.startsWith(thisString + "."); + } @NotNull public static FqName topLevel(@NotNull Name shortName) { diff --git a/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/AbstractScopeAdapter.java b/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/AbstractScopeAdapter.java index 1bb8bdea77b..d6d8448585a 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/AbstractScopeAdapter.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/AbstractScopeAdapter.java @@ -46,8 +46,8 @@ public abstract class AbstractScopeAdapter implements JetScope { } @Override - public NamespaceDescriptor getNamespace(@NotNull Name name) { - return getWorkerScope().getNamespace(name); + public PackageViewDescriptor getPackage(@NotNull Name name) { + return getWorkerScope().getPackage(name); } @Override diff --git a/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/ChainedScope.java b/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/ChainedScope.java index 9fd79631aa6..5ce29f76582 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/ChainedScope.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/ChainedScope.java @@ -58,11 +58,11 @@ public class ChainedScope implements JetScope { } @Override - public NamespaceDescriptor getNamespace(@NotNull Name name) { + public PackageViewDescriptor getPackage(@NotNull Name name) { for (JetScope jetScope : scopeChain) { - NamespaceDescriptor namespace = jetScope.getNamespace(name); - if (namespace != null) { - return namespace; + PackageViewDescriptor aPackage = jetScope.getPackage(name); + if (aPackage != null) { + return aPackage; } } return null; diff --git a/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/FilteringScope.java b/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/FilteringScope.java index 3e92102e29a..1b036d4898a 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/FilteringScope.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/FilteringScope.java @@ -55,9 +55,10 @@ public class FilteringScope implements JetScope { return descriptor != null && predicate.apply(descriptor) ? descriptor : null; } + @Nullable @Override - public NamespaceDescriptor getNamespace(@NotNull Name name) { - return filterDescriptor(workerScope.getNamespace(name)); + public PackageViewDescriptor getPackage(@NotNull Name name) { + return filterDescriptor(workerScope.getPackage(name)); } @Override diff --git a/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/JetScope.java b/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/JetScope.java index 03c6cc41fa7..85b15eddbbe 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/JetScope.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/JetScope.java @@ -54,7 +54,7 @@ public interface JetScope { ClassifierDescriptor getClassifier(@NotNull Name name); @Nullable - NamespaceDescriptor getNamespace(@NotNull Name name); + PackageViewDescriptor getPackage(@NotNull Name name); @NotNull @ReadOnly diff --git a/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeImpl.java b/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeImpl.java index 992e0f50fdd..2e4d883e616 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeImpl.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeImpl.java @@ -17,6 +17,7 @@ package org.jetbrains.jet.lang.resolve.scopes; import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; import org.jetbrains.annotations.TestOnly; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.resolve.name.LabelName; @@ -44,8 +45,9 @@ public abstract class JetScopeImpl implements JetScope { return null; } + @Nullable @Override - public NamespaceDescriptor getNamespace(@NotNull Name name) { + public PackageViewDescriptor getPackage(@NotNull Name name) { return null; } diff --git a/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/SubstitutingScope.java b/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/SubstitutingScope.java index 86a260623f7..9a53bdbbf5d 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/SubstitutingScope.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/SubstitutingScope.java @@ -105,8 +105,8 @@ public class SubstitutingScope implements JetScope { } @Override - public NamespaceDescriptor getNamespace(@NotNull Name name) { - return workerScope.getNamespace(name); // TODO + public PackageViewDescriptor getPackage(@NotNull Name name) { + return workerScope.getPackage(name); } @NotNull diff --git a/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/WritableScope.java b/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/WritableScope.java index 80dbf725fc7..46474f40ba0 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/WritableScope.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/WritableScope.java @@ -45,7 +45,7 @@ public interface WritableScope extends JetScope { void addClassifierAlias(@NotNull Name name, @NotNull ClassifierDescriptor classifierDescriptor); - void addNamespaceAlias(@NotNull Name name, @NotNull NamespaceDescriptor namespaceDescriptor); + void addPackageAlias(@NotNull Name name, @NotNull PackageViewDescriptor packageView); void addFunctionAlias(@NotNull Name name, @NotNull FunctionDescriptor functionDescriptor); @@ -53,6 +53,7 @@ public interface WritableScope extends JetScope { void addNamespace(@NotNull NamespaceDescriptor namespaceDescriptor); + @Deprecated @Nullable NamespaceDescriptor getDeclaredNamespace(@NotNull Name name); @@ -64,7 +65,7 @@ public interface WritableScope extends JetScope { void importClassifierAlias(@NotNull Name importedClassifierName, @NotNull ClassifierDescriptor classifierDescriptor); - void importNamespaceAlias(@NotNull Name aliasName, @NotNull NamespaceDescriptor namespaceDescriptor); + void importPackageAlias(@NotNull Name aliasName, @NotNull PackageViewDescriptor packageView); void importFunctionAlias(@NotNull Name aliasName, @NotNull FunctionDescriptor functionDescriptor); diff --git a/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java b/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java index c6285901c7d..0e8c59f359d 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java @@ -29,6 +29,13 @@ import org.jetbrains.jet.utils.Printer; import java.util.*; +// Reads from: +// 1. Maps +// 2. Worker +// 3. Imports + +// Writes to: maps + public class WritableScopeImpl extends WritableScopeWithImports { private final Collection allDescriptors = Lists.newArrayList(); @@ -48,7 +55,7 @@ public class WritableScopeImpl extends WritableScopeWithImports { private SetMultimap propertyGroups; @Nullable - private Map namespaceAliases; + private Map packageAliases; @Nullable private Map> labelsToDescriptors; @@ -83,11 +90,11 @@ public class WritableScopeImpl extends WritableScopeWithImports { } @Override - public void importNamespaceAlias(@NotNull Name aliasName, @NotNull NamespaceDescriptor namespaceDescriptor) { + public void importPackageAlias(@NotNull Name aliasName, @NotNull PackageViewDescriptor packageView) { checkMayWrite(); - allDescriptors.add(namespaceDescriptor); - super.importNamespaceAlias(aliasName, namespaceDescriptor); + allDescriptors.add(packageView); + super.importPackageAlias(aliasName, packageView); } @Override @@ -181,11 +188,11 @@ public class WritableScopeImpl extends WritableScopeWithImports { } @NotNull - private Map getNamespaceAliases() { - if (namespaceAliases == null) { - namespaceAliases = Maps.newHashMap(); + private Map getPackageAliases() { + if (packageAliases == null) { + packageAliases = Maps.newHashMap(); } - return namespaceAliases; + return packageAliases; } @Override @@ -310,13 +317,13 @@ public class WritableScopeImpl extends WritableScopeWithImports { } @Override - public void addNamespaceAlias(@NotNull Name name, @NotNull NamespaceDescriptor namespaceDescriptor) { + public void addPackageAlias(@NotNull Name name, @NotNull PackageViewDescriptor packageView) { checkMayWrite(); - checkForRedeclaration(name, namespaceDescriptor); - getNamespaceAliases().put(name, namespaceDescriptor); - allDescriptors.add(namespaceDescriptor); - addToDeclared(namespaceDescriptor); + checkForRedeclaration(name, packageView); + getPackageAliases().put(name, packageView); + allDescriptors.add(packageView); + addToDeclared(packageView); } @Override @@ -395,18 +402,19 @@ public class WritableScopeImpl extends WritableScopeWithImports { } @Override - public NamespaceDescriptor getNamespace(@NotNull Name name) { + public PackageViewDescriptor getPackage(@NotNull Name name) { checkMayRead(); - NamespaceDescriptor declaredNamespace = getDeclaredNamespace(name); - if (declaredNamespace != null) return declaredNamespace; + // TODO 1 + //NamespaceDescriptor declaredNamespace = getDeclaredNamespace(name); + //if (declaredNamespace != null) return declaredNamespace; - NamespaceDescriptor aliased = getNamespaceAliases().get(name); + PackageViewDescriptor aliased = getPackageAliases().get(name); if (aliased != null) return aliased; - NamespaceDescriptor namespace = getWorkerScope().getNamespace(name); - if (namespace != null) return namespace; - return super.getNamespace(name); + PackageViewDescriptor packageView = getWorkerScope().getPackage(name); + if (packageView != null) return packageView; + return super.getPackage(name); } @Override diff --git a/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeWithImports.java b/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeWithImports.java index 1f8f8d40838..f8810dadd96 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeWithImports.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeWithImports.java @@ -176,11 +176,11 @@ public abstract class WritableScopeWithImports extends JetScopeAdapter implement } @Override - public NamespaceDescriptor getNamespace(@NotNull Name name) { + public PackageViewDescriptor getPackage(@NotNull Name name) { checkMayRead(); for (JetScope imported : getImports()) { - NamespaceDescriptor importedDescriptor = imported.getNamespace(name); + PackageViewDescriptor importedDescriptor = imported.getPackage(name); if (importedDescriptor != null) { return importedDescriptor; } @@ -206,10 +206,10 @@ public abstract class WritableScopeWithImports extends JetScopeAdapter implement } @Override - public void importNamespaceAlias(@NotNull Name aliasName, @NotNull NamespaceDescriptor namespaceDescriptor) { + public void importPackageAlias(@NotNull Name aliasName, @NotNull PackageViewDescriptor packageView) { checkMayWrite(); - getCurrentIndividualImportScope().addNamespaceAlias(aliasName, namespaceDescriptor); + getCurrentIndividualImportScope().addPackageAlias(aliasName, packageView); } @Override diff --git a/core/descriptors/src/org/jetbrains/jet/lang/types/ErrorUtils.java b/core/descriptors/src/org/jetbrains/jet/lang/types/ErrorUtils.java index f73cf8ff1cc..a4dc43ced62 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/types/ErrorUtils.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/types/ErrorUtils.java @@ -100,8 +100,8 @@ public class ErrorUtils { } @Override - public NamespaceDescriptor getNamespace(@NotNull Name name) { - return null; // TODO : review + public PackageViewDescriptor getPackage(@NotNull Name name) { + return null; } @NotNull @@ -166,7 +166,7 @@ public class ErrorUtils { @Nullable @Override - public NamespaceDescriptor getNamespace(@NotNull Name name) { + public PackageViewDescriptor getPackage(@NotNull Name name) { throw new IllegalStateException(); } diff --git a/core/descriptors/src/org/jetbrains/jet/lang/types/lang/BuiltInsSerializationUtil.java b/core/descriptors/src/org/jetbrains/jet/lang/types/lang/BuiltInsSerializationUtil.java index fac047cbf4c..fb2293d6d2b 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/types/lang/BuiltInsSerializationUtil.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/types/lang/BuiltInsSerializationUtil.java @@ -18,8 +18,7 @@ package org.jetbrains.jet.lang.types.lang; import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.descriptors.serialization.ClassId; -import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; -import org.jetbrains.jet.lang.resolve.DescriptorUtils; +import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.resolve.name.Name; @@ -51,30 +50,30 @@ public class BuiltInsSerializationUtil { @NotNull public static String getClassMetadataPath(@NotNull ClassId classId) { - return packageFqNameToPath(classId.getPackageFqName().toUnsafe()) + return packageFqNameToPath(classId.getPackageFqName()) + "/" + relativeClassNameToFilePath(classId.getRelativeClassName()) + "." + CLASS_METADATA_FILE_EXTENSION; } @NotNull - public static String getPackageFilePath(@NotNull NamespaceDescriptor packageDescriptor) { - FqNameUnsafe fqName = DescriptorUtils.getFQName(packageDescriptor); + public static String getPackageFilePath(@NotNull PackageFragmentDescriptor packageFragment) { + FqName fqName = packageFragment.getFqName(); return packageFqNameToPath(fqName) + "/" + PACKAGE_FILE_NAME; } @NotNull - public static String getNameTableFilePath(@NotNull NamespaceDescriptor packageDescriptor) { - FqNameUnsafe fqName = DescriptorUtils.getFQName(packageDescriptor); + public static String getNameTableFilePath(@NotNull PackageFragmentDescriptor packageFragment) { + FqName fqName = packageFragment.getFqName(); return packageFqNameToPath(fqName) + "/" + NAME_TABLE_FILE_NAME; } @NotNull - public static String getClassNamesFilePath(@NotNull NamespaceDescriptor packageDescriptor) { - FqNameUnsafe fqName = DescriptorUtils.getFQName(packageDescriptor); + public static String getClassNamesFilePath(@NotNull PackageFragmentDescriptor packageFragmentDescriptor) { + FqName fqName = packageFragmentDescriptor.getFqName(); return packageFqNameToPath(fqName) + "/" + CLASS_NAMES_FILE_NAME; } - private static String packageFqNameToPath(FqNameUnsafe fqName) { + private static String packageFqNameToPath(FqName fqName) { return fqName.asString().replace('.', '/'); } } diff --git a/core/descriptors/src/org/jetbrains/jet/lang/types/lang/BuiltinsNamespaceDescriptorImpl.java b/core/descriptors/src/org/jetbrains/jet/lang/types/lang/BuiltinsPackageFragment.java similarity index 81% rename from core/descriptors/src/org/jetbrains/jet/lang/types/lang/BuiltinsNamespaceDescriptorImpl.java rename to core/descriptors/src/org/jetbrains/jet/lang/types/lang/BuiltinsPackageFragment.java index b7349006c45..5bcb09d44fa 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/types/lang/BuiltinsNamespaceDescriptorImpl.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/types/lang/BuiltinsPackageFragment.java @@ -5,12 +5,13 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.descriptors.serialization.*; import org.jetbrains.jet.descriptors.serialization.descriptors.DeserializedPackageMemberScope; -import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; -import org.jetbrains.jet.lang.descriptors.impl.AbstractNamespaceDescriptorImpl; +import org.jetbrains.jet.lang.descriptors.impl.DeclarationDescriptorImpl; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; +import org.jetbrains.jet.lang.types.TypeSubstitutor; import org.jetbrains.jet.storage.NotNullLazyValue; import org.jetbrains.jet.storage.StorageManager; @@ -24,13 +25,14 @@ import java.util.List; import static org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationDeserializer.UNSUPPORTED; -class BuiltinsNamespaceDescriptorImpl extends AbstractNamespaceDescriptorImpl { +class BuiltinsPackageFragment extends DeclarationDescriptorImpl implements PackageFragmentDescriptor { private final DeserializedPackageMemberScope members; private final NameResolver nameResolver; + private final ModuleDescriptor module; - public BuiltinsNamespaceDescriptorImpl(@NotNull StorageManager storageManager, @NotNull NamespaceDescriptor containingDeclaration) { - super(containingDeclaration, Collections.emptyList(), KotlinBuiltIns.BUILT_INS_PACKAGE_NAME); - + public BuiltinsPackageFragment(@NotNull StorageManager storageManager, @NotNull ModuleDescriptor module) { + super(Collections.emptyList(), KotlinBuiltIns.BUILT_INS_PACKAGE_NAME); + this.module = module; nameResolver = NameSerializationUtil.deserializeNameResolver(getStream(BuiltInsSerializationUtil.getNameTableFilePath(this))); members = new DeserializedPackageMemberScope(storageManager, this, UNSUPPORTED, new BuiltInsDescriptorFinder(storageManager), @@ -55,6 +57,23 @@ class BuiltinsNamespaceDescriptorImpl extends AbstractNamespaceDescriptorImpl { return members; } + @NotNull + @Override + public ModuleDescriptor getContainingDeclaration() { + return module; + } + + @Nullable + @Override + public DeclarationDescriptor substitute(@NotNull TypeSubstitutor substitutor) { + return this; + } + + @Override + public R accept(DeclarationDescriptorVisitor visitor, D data) { + return visitor.visitPackageFragmentDescriptor(this, data); + } + @NotNull @Override public FqName getFqName() { @@ -85,7 +104,7 @@ class BuiltinsNamespaceDescriptorImpl extends AbstractNamespaceDescriptorImpl { @Override @NotNull public Collection invoke() { - InputStream in = getStream(BuiltInsSerializationUtil.getClassNamesFilePath(BuiltinsNamespaceDescriptorImpl.this)); + InputStream in = getStream(BuiltInsSerializationUtil.getClassNamesFilePath(BuiltinsPackageFragment.this)); try { DataInputStream data = new DataInputStream(in); @@ -136,8 +155,8 @@ class BuiltinsNamespaceDescriptorImpl extends AbstractNamespaceDescriptorImpl { @Nullable @Override - public NamespaceDescriptor findPackage(@NotNull FqName fqName) { - return fqName.equals(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME) ? BuiltinsNamespaceDescriptorImpl.this : null; + public PackageFragmentDescriptor findPackage(@NotNull FqName fqName) { + return fqName.equals(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME) ? BuiltinsPackageFragment.this : null; } @NotNull diff --git a/core/descriptors/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java b/core/descriptors/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java index 1128453377e..47253534145 100644 --- a/core/descriptors/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java +++ b/core/descriptors/src/org/jetbrains/jet/lang/types/lang/KotlinBuiltIns.java @@ -25,16 +25,13 @@ import org.jetbrains.jet.lang.ModuleConfiguration; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; -import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorImpl; +import org.jetbrains.jet.lang.descriptors.impl.MutablePackageFragmentDescriptor; import org.jetbrains.jet.lang.descriptors.impl.ValueParameterDescriptorImpl; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.name.SpecialNames; import org.jetbrains.jet.lang.resolve.scopes.JetScope; -import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler; -import org.jetbrains.jet.lang.resolve.scopes.WritableScope; -import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl; import org.jetbrains.jet.lang.types.*; import org.jetbrains.jet.storage.LockBasedStorageManager; @@ -163,15 +160,31 @@ public class KotlinBuiltIns { } private static void loadBuiltIns(@NotNull ModuleDescriptorImpl module) throws IOException { - NamespaceDescriptorImpl rootNamespace = - new NamespaceDescriptorImpl(module, Collections.emptyList(), SpecialNames.ROOT_NAMESPACE); - rootNamespace.initialize( - new WritableScopeImpl(JetScope.EMPTY, rootNamespace, RedeclarationHandler.DO_NOTHING, "members of root namespace")); + final PackageFragmentDescriptor rootPackage = new MutablePackageFragmentDescriptor(module, FqName.ROOT); + final PackageFragmentDescriptor builtinsPackage = new BuiltinsPackageFragment(new LockBasedStorageManager(), module); - module.setRootNamespace(rootNamespace); + module.addFragmentProvider(new PackageFragmentProvider() { + @NotNull + @Override + public List getPackageFragments(@NotNull FqName fqName) { + if (fqName.isRoot()) { + return Collections.singletonList(rootPackage); + } + else if (BUILT_INS_PACKAGE_FQ_NAME.equals(fqName)) { + return Collections.singletonList(builtinsPackage); + } + return Collections.emptyList(); + } - rootNamespace.getMemberScope().addNamespace(new BuiltinsNamespaceDescriptorImpl(new LockBasedStorageManager(), rootNamespace)); - rootNamespace.getMemberScope().changeLockLevel(WritableScope.LockLevel.READING); + @NotNull + @Override + public Collection getSubPackagesOf(@NotNull FqName fqName) { + if (fqName.isRoot()) { + return Collections.singleton(BUILT_INS_PACKAGE_FQ_NAME); + } + return Collections.emptyList(); + } + }); } private void doInitialize() { @@ -213,20 +226,20 @@ public class KotlinBuiltIns { } @NotNull - public NamespaceDescriptor getBuiltInsPackage() { - NamespaceDescriptor namespace = getBuiltInsModule().getNamespace(BUILT_INS_PACKAGE_FQ_NAME); - assert namespace != null : "Built ins namespace not found: " + BUILT_INS_PACKAGE_FQ_NAME; - return namespace; + public PackageFragmentDescriptor getBuiltInsPackageFragment() { + return builtInsModule.getPackageFragmentProvider().getPackageFragments(BUILT_INS_PACKAGE_FQ_NAME).get(0); } + // TODO 1 inline @NotNull public FqName getBuiltInsPackageFqName() { - return getBuiltInsPackage().getFqName(); + return BUILT_INS_PACKAGE_FQ_NAME; } + @Deprecated @NotNull - public JetScope getBuiltInsScope() { - return getBuiltInsPackage().getMemberScope(); + public JetScope getBuiltInsScope() { // TODO 1 scope? + return getBuiltInsPackageFragment().getMemberScope(); } //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/core/descriptors/src/org/jetbrains/jet/renderer/DescriptorRendererImpl.java b/core/descriptors/src/org/jetbrains/jet/renderer/DescriptorRendererImpl.java index 3a7d28ef2b3..6d653ae1b1a 100644 --- a/core/descriptors/src/org/jetbrains/jet/renderer/DescriptorRendererImpl.java +++ b/core/descriptors/src/org/jetbrains/jet/renderer/DescriptorRendererImpl.java @@ -690,13 +690,19 @@ public class DescriptorRendererImpl implements DescriptorRenderer { private void renderPackageView(@NotNull PackageViewDescriptor packageView, @NotNull StringBuilder builder) { builder.append(renderKeyword("package")).append(" "); renderName(packageView, builder); + if (debugMode) { + builder.append(" in context of "); + renderName(packageView.getModule(), builder); + } } private void renderPackageFragment(@NotNull PackageFragmentDescriptor fragment, @NotNull StringBuilder builder) { builder.append(renderKeyword("package-fragment")).append(" "); renderName(fragment, builder); - builder.append(" in context of "); - renderName(fragment.getContainingDeclaration(), builder); + if (debugMode) { + builder.append(" in context of "); + renderName(fragment.getContainingDeclaration(), builder); + } } diff --git a/generators/src/org/jetbrains/jet/generators/builtins/BuiltInsSerializer.java b/generators/src/org/jetbrains/jet/generators/builtins/BuiltInsSerializer.java index 8984a2440de..9547de99edf 100644 --- a/generators/src/org/jetbrains/jet/generators/builtins/BuiltInsSerializer.java +++ b/generators/src/org/jetbrains/jet/generators/builtins/BuiltInsSerializer.java @@ -26,10 +26,7 @@ import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; import org.jetbrains.jet.config.CompilerConfiguration; import org.jetbrains.jet.descriptors.serialization.*; -import org.jetbrains.jet.lang.descriptors.ClassDescriptor; -import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; -import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; +import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.lazy.LazyResolveTestUtil; @@ -40,6 +37,7 @@ import org.jetbrains.jet.test.util.DescriptorValidator; import java.io.*; import java.util.ArrayList; +import java.util.Collections; import java.util.List; import java.util.regex.Pattern; @@ -68,10 +66,11 @@ public class BuiltInsSerializer { ModuleDescriptor module = LazyResolveTestUtil.resolveLazily(files, environment, false); - NamespaceDescriptor namespace = module.getNamespace(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME); - assert namespace != null : "No built-ins namespace: " + KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME; + PackageFragmentDescriptor fragmentDescriptor = module.getPackageFragmentProvider() + .getPackageFragments(KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME).get(0); // TODO 1 hack + assert fragmentDescriptor != null : "No built-ins package: " + KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME; - DescriptorValidator.validate(namespace); + DescriptorValidator.validate(fragmentDescriptor); if (!FileUtil.delete(destDir)) { System.err.println("Could not delete: " + destDir); @@ -90,7 +89,7 @@ public class BuiltInsSerializer { }); final List classNames = new ArrayList(); - List allDescriptors = DescriptorSerializer.sort(namespace.getMemberScope().getAllDescriptors()); + List allDescriptors = DescriptorSerializer.sort(fragmentDescriptor.getMemberScope().getAllDescriptors()); ClassSerializationUtil.serializeClasses(allDescriptors, serializer, new ClassSerializationUtil.Sink() { @Override public void writeClass(@NotNull ClassDescriptor classDescriptor, @NotNull ProtoBuf.Class classProto) { @@ -111,16 +110,16 @@ public class BuiltInsSerializer { ByteArrayOutputStream classNamesStream = new ByteArrayOutputStream(); writeClassNames(serializer, classNames, classNamesStream); - write(destDir, BuiltInsSerializationUtil.getClassNamesFilePath(namespace), classNamesStream, out); + write(destDir, BuiltInsSerializationUtil.getClassNamesFilePath(fragmentDescriptor), classNamesStream, out); ByteArrayOutputStream packageStream = new ByteArrayOutputStream(); - ProtoBuf.Package packageProto = serializer.packageProto(namespace).build(); + ProtoBuf.Package packageProto = serializer.packageProto(Collections.singleton(fragmentDescriptor)).build(); packageProto.writeTo(packageStream); - write(destDir, BuiltInsSerializationUtil.getPackageFilePath(namespace), packageStream, out); + write(destDir, BuiltInsSerializationUtil.getPackageFilePath(fragmentDescriptor), packageStream, out); ByteArrayOutputStream nameStream = new ByteArrayOutputStream(); NameSerializationUtil.serializeNameTable(nameStream, serializer.getNameTable()); - write(destDir, BuiltInsSerializationUtil.getNameTableFilePath(namespace), nameStream, out); + write(destDir, BuiltInsSerializationUtil.getNameTableFilePath(fragmentDescriptor), nameStream, out); if (out != null) { out.println("Total bytes written: " + totalSize + " to " + totalFiles + " files"); diff --git a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.java b/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.java index bc9166436e2..3b29eee5131 100644 --- a/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.java +++ b/generators/src/org/jetbrains/jet/generators/injectors/GenerateInjectors.java @@ -103,6 +103,7 @@ public class GenerateInjectors { DependencyInjectorGenerator generator = new DependencyInjectorGenerator(); generateInjectorForTopDownAnalyzerCommon(generator); generator.addField(DependencyClassByQualifiedNameResolverDummyImpl.class); + generator.addField(MutablePackageFragmentProvider.class); generator.addField(NamespaceFactoryImpl.class); generator.addParameter(PlatformToKotlinClassMap.class); generator.configure("compiler/frontend/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerBasic", GenerateInjectors.class); @@ -113,6 +114,7 @@ public class GenerateInjectors { DependencyInjectorGenerator generator = new DependencyInjectorGenerator(); generateInjectorForTopDownAnalyzerCommon(generator); generator.addField(DependencyClassByQualifiedNameResolverDummyImpl.class); + generator.addField(MutablePackageFragmentProvider.class); generator.addField(NamespaceFactoryImpl.class); generator.addField(false, PlatformToKotlinClassMap.class, null, new GivenExpression("org.jetbrains.jet.lang.PlatformToKotlinClassMap.EMPTY")); generator.configure("js/js.translator/src", "org.jetbrains.jet.di", "InjectorForTopDownAnalyzerForJs", GenerateInjectors.class); @@ -133,7 +135,8 @@ public class GenerateInjectors { generator.addField(PsiBasedMethodSignatureChecker.class); generator.addField(PsiBasedExternalAnnotationResolver.class); generator.addField(VirtualFileKotlinClassFinder.class); - generator.addPublicField(NamespaceFactoryImpl.class); + generator.addField(MutablePackageFragmentProvider.class); + generator.addField(NamespaceFactoryImpl.class); generator.addField(false, VirtualFileFinder.class, "virtualFileFinder", new GivenExpression( "com.intellij.openapi.components.ServiceManager.getService(project, VirtualFileFinder.class)")); @@ -160,9 +163,11 @@ public class GenerateInjectors { generator.addField(VirtualFileKotlinClassFinder.class); generator.addField(false, VirtualFileFinder.class, "virtualFileFinder", new GivenExpression("com.intellij.openapi.components.ServiceManager.getService(project, VirtualFileFinder.class)")); + generator.addField(true, ModuleDescriptorImpl.class, "module", + new GivenExpression("org.jetbrains.jet.lang.resolve.java.AnalyzerFacadeForJVM.createJavaModule(\"\")")); generator.configure("compiler/frontend.java/src", "org.jetbrains.jet.di", "InjectorForJavaDescriptorResolver", - GenerateInjectors.class); + GenerateInjectors.class); return generator; } diff --git a/idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.java b/idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.java index 2ff06626bbc..aee4bc0489f 100644 --- a/idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.java +++ b/idea/src/org/jetbrains/jet/plugin/caches/JetShortNamesCache.java @@ -244,7 +244,7 @@ public class JetShortNamesCache extends PsiShortNamesCache { for (FqName fqName : topLevelFunctionFqNames) { JetImportDirective importDirective = JetPsiFactory.createImportDirective(project, new ImportPath(fqName, false)); Collection declarationDescriptors = new QualifiedExpressionResolver().analyseImportReference( - importDirective, jetScope, new BindingTraceContext(), resolveSession.getRootModuleDescriptor()); + importDirective, jetScope, new BindingTraceContext(), resolveSession.getModuleDescriptor()); for (DeclarationDescriptor declarationDescriptor : declarationDescriptors) { if (declarationDescriptor instanceof FunctionDescriptor) { result.add((FunctionDescriptor) declarationDescriptor); @@ -267,7 +267,7 @@ public class JetShortNamesCache extends PsiShortNamesCache { } for (FqName affectedPackage : affectedPackages) { - NamespaceDescriptor packageDescriptor = resolveSession.getPackageDescriptorByFqName(affectedPackage); + PackageViewDescriptor packageDescriptor = resolveSession.getModuleDescriptor().getPackage(affectedPackage); assert packageDescriptor != null : "There's a function in stub index with invalid package: " + affectedPackage; JetScope memberScope = packageDescriptor.getMemberScope(); result.addAll(memberScope.getFunctions(referenceName)); @@ -316,7 +316,7 @@ public class JetShortNamesCache extends PsiShortNamesCache { // Iterate through the function with attempt to resolve found functions for (FqName functionFQN : functionFQNs) { for (CallableDescriptor functionDescriptor : ExpressionTypingUtils.canFindSuitableCall( - functionFQN, project, receiverExpression, expressionType, scope, resolveSession.getRootModuleDescriptor())) { + functionFQN, project, receiverExpression, expressionType, scope, resolveSession.getModuleDescriptor())) { resultDescriptors.add(functionDescriptor); } diff --git a/idea/src/org/jetbrains/jet/plugin/caches/resolve/JvmDeclarationsCacheProvider.java b/idea/src/org/jetbrains/jet/plugin/caches/resolve/JvmDeclarationsCacheProvider.java index 22b6d84583b..2fe38f0f554 100644 --- a/idea/src/org/jetbrains/jet/plugin/caches/resolve/JvmDeclarationsCacheProvider.java +++ b/idea/src/org/jetbrains/jet/plugin/caches/resolve/JvmDeclarationsCacheProvider.java @@ -57,15 +57,14 @@ class JvmDeclarationsCacheProvider extends DeclarationsCacheProvider { // This lock is already acquired by the calling method, // but we put it here to guard for the case of further modifications synchronized (declarationAnalysisLock) { - BindingTraceContext trace = new BindingTraceContext(); + incompleteTrace = new BindingTraceContext(); - incompleteTrace = trace; AnalyzeExhaust analyzeExhaust; try { analyzeExhaust = AnalyzerFacadeForJVM.analyzeFilesWithJavaIntegration( project, JetFilesProvider.getInstance(project).allInScope(GlobalSearchScope.allScope(project)), - trace, + incompleteTrace, Collections.emptyList(), Predicates.alwaysFalse(), true); @@ -90,11 +89,13 @@ class JvmDeclarationsCacheProvider extends DeclarationsCacheProvider { synchronized (declarationAnalysisLock) { if (allowIncomplete) { if (incompleteTrace != null) { + // saving context to local variable to avoid race condition + final BindingContext context = incompleteTrace.getBindingContext(); return new KotlinDeclarationsCache() { @NotNull @Override public BindingContext getBindingContext() { - return incompleteTrace.getBindingContext(); + return context; } }; } diff --git a/idea/src/org/jetbrains/jet/plugin/findUsages/JetUsageTypeProvider.kt b/idea/src/org/jetbrains/jet/plugin/findUsages/JetUsageTypeProvider.kt index 73c38427496..1013b239b09 100644 --- a/idea/src/org/jetbrains/jet/plugin/findUsages/JetUsageTypeProvider.kt +++ b/idea/src/org/jetbrains/jet/plugin/findUsages/JetUsageTypeProvider.kt @@ -31,7 +31,7 @@ import org.jetbrains.jet.lang.resolve.BindingContext import org.jetbrains.jet.lexer.JetTokens import org.jetbrains.jet.plugin.project.AnalyzerFacadeWithCache import org.jetbrains.jet.plugin.JetBundle -import org.jetbrains.jet.lang.resolve.java.descriptor.JavaNamespaceDescriptor +import org.jetbrains.jet.lang.resolve.java.descriptor.JavaPackageFragmentDescriptor import org.jetbrains.jet.lang.resolve.DescriptorUtils public object JetUsageTypeProvider : UsageTypeProviderEx { @@ -185,7 +185,7 @@ public object JetUsageTypeProvider : UsageTypeProviderEx { } else { getClassUsageType() } - is JavaNamespaceDescriptor -> getClassUsageType() + is JavaPackageFragmentDescriptor -> getClassUsageType() is VariableDescriptor -> getVariableUsageType() is FunctionDescriptor -> getFunctionUsageType(descriptor) else -> null diff --git a/idea/src/org/jetbrains/jet/plugin/project/CancelableResolveSession.java b/idea/src/org/jetbrains/jet/plugin/project/CancelableResolveSession.java index 9d2a8e51f1d..78babba620e 100644 --- a/idea/src/org/jetbrains/jet/plugin/project/CancelableResolveSession.java +++ b/idea/src/org/jetbrains/jet/plugin/project/CancelableResolveSession.java @@ -21,11 +21,9 @@ import com.intellij.openapi.project.Project; import com.intellij.openapi.util.Computable; import com.intellij.openapi.util.ModificationTracker; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.ModuleDescriptor; -import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor; import org.jetbrains.jet.lang.psi.JetClassOrObject; import org.jetbrains.jet.lang.psi.JetDeclaration; import org.jetbrains.jet.lang.psi.JetElement; @@ -33,8 +31,6 @@ import org.jetbrains.jet.lang.psi.JetFile; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.lazy.KotlinCodeAnalyzer; import org.jetbrains.jet.lang.resolve.lazy.ResolveSession; -import org.jetbrains.jet.lang.resolve.name.FqName; -import org.jetbrains.jet.lang.resolve.name.Name; import java.util.concurrent.atomic.AtomicLong; @@ -69,22 +65,11 @@ public class CancelableResolveSession implements KotlinCodeAnalyzer, Modificatio } @Override - public ModuleDescriptor getRootModuleDescriptor() { + public ModuleDescriptor getModuleDescriptor() { return computableWithProcessingCancel(new Computable() { @Override public ModuleDescriptor compute() { - return resolveSession.getRootModuleDescriptor(); - } - }); - } - - @Nullable - @Override - public NamespaceDescriptor getPackageDescriptorByFqName(final FqName fqName) { - return computableWithProcessingCancel(new Computable() { - @Override - public NamespaceDescriptor compute() { - return resolveSession.getPackageDescriptorByFqName(fqName); + return resolveSession.getModuleDescriptor(); } }); } diff --git a/idea/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java b/idea/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java index ca63d46f815..6e82654c412 100644 --- a/idea/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java +++ b/idea/src/org/jetbrains/jet/plugin/project/ResolveElementCache.java @@ -189,7 +189,7 @@ public class ResolveElementCache { if (Name.isValidIdentifier(name.asString())) { if (trace.getBindingContext().get(BindingContext.REFERENCE_TARGET, packageNameExpression) == null) { FqName fqName = header.getParentFqName(packageNameExpression).child(name); - NamespaceDescriptor packageDescriptor = resolveSession.getPackageDescriptorByFqName(fqName); + PackageViewDescriptor packageDescriptor = resolveSession.getModuleDescriptor().getPackage(fqName); assert packageDescriptor != null: "Package descriptor should be present in session for " + fqName; trace.record(BindingContext.REFERENCE_TARGET, packageNameExpression, packageDescriptor); } @@ -231,7 +231,7 @@ public class ResolveElementCache { private static void delegationSpecifierAdditionalResolve( KotlinCodeAnalyzer analyzer, JetDelegationSpecifierList specifier, BindingTrace trace, JetFile file) { - BodyResolver bodyResolver = createBodyResolverWithEmptyContext(trace, file, analyzer.getRootModuleDescriptor()); + BodyResolver bodyResolver = createBodyResolverWithEmptyContext(trace, file, analyzer.getModuleDescriptor()); JetClassOrObject classOrObject = (JetClassOrObject) specifier.getParent(); LazyClassDescriptor descriptor = (LazyClassDescriptor) analyzer.resolveToDescriptor(classOrObject); @@ -256,7 +256,7 @@ public class ResolveElementCache { return propertyResolutionScope; } }); - BodyResolver bodyResolver = createBodyResolver(trace, file, bodyResolveContext, resolveSession.getRootModuleDescriptor()); + BodyResolver bodyResolver = createBodyResolver(trace, file, bodyResolveContext, resolveSession.getModuleDescriptor()); PropertyDescriptor descriptor = (PropertyDescriptor) resolveSession.resolveToDescriptor(jetProperty); JetExpression propertyInitializer = jetProperty.getInitializer(); @@ -278,7 +278,7 @@ public class ResolveElementCache { BindingTrace trace, JetFile file ) { - BodyResolver bodyResolver = createBodyResolverWithEmptyContext(trace, file, resolveSession.getRootModuleDescriptor()); + BodyResolver bodyResolver = createBodyResolverWithEmptyContext(trace, file, resolveSession.getModuleDescriptor()); JetScope scope = resolveSession.getInjector().getScopeProvider().getResolutionScopeForDeclaration(namedFunction); FunctionDescriptor functionDescriptor = (FunctionDescriptor) resolveSession.resolveToDescriptor(namedFunction); bodyResolver.resolveFunctionBody(trace, namedFunction, functionDescriptor, scope); @@ -290,7 +290,7 @@ public class ResolveElementCache { BindingTrace trace, JetFile file ) { - BodyResolver bodyResolver = createBodyResolverWithEmptyContext(trace, file, resolveSession.getRootModuleDescriptor()); + BodyResolver bodyResolver = createBodyResolverWithEmptyContext(trace, file, resolveSession.getModuleDescriptor()); JetScope scope = resolveSession.getInjector().getScopeProvider().getResolutionScopeForDeclaration(klass); ClassDescriptor classDescriptor = (ClassDescriptor) resolveSession.resolveToDescriptor(klass); @@ -306,7 +306,7 @@ public class ResolveElementCache { BindingTrace trace, JetFile file ) { - BodyResolver bodyResolver = createBodyResolverWithEmptyContext(trace, file, analyzer.getRootModuleDescriptor()); + BodyResolver bodyResolver = createBodyResolverWithEmptyContext(trace, file, analyzer.getModuleDescriptor()); JetClassOrObject classOrObject = PsiTreeUtil.getParentOfType(classInitializer, JetClassOrObject.class); LazyClassDescriptor classOrObjectDescriptor = (LazyClassDescriptor) analyzer.resolveToDescriptor(classOrObject); bodyResolver.resolveAnonymousInitializers(classOrObject, classOrObjectDescriptor.getUnsubstitutedPrimaryConstructor(), @@ -364,15 +364,16 @@ public class ResolveElementCache { // Inside import if (PsiTreeUtil.getParentOfType(expression, JetImportDirective.class, false) != null) { - NamespaceDescriptor rootPackage = resolveSession.getPackageDescriptorByFqName(FqName.ROOT); + PackageViewDescriptor rootPackage = resolveSession.getModuleDescriptor().getPackage(FqName.ROOT); assert rootPackage != null; if (expression.getParent() instanceof JetDotQualifiedExpression) { JetExpression element = ((JetDotQualifiedExpression) expression.getParent()).getReceiverExpression(); String name = ((JetFile) expression.getContainingFile()).getPackageName(); - NamespaceDescriptor filePackage = - name != null ? resolveSession.getPackageDescriptorByFqName(new FqName(name)) : rootPackage; + PackageViewDescriptor filePackage = name != null + ? resolveSession.getModuleDescriptor().getPackage(new FqName(name)) + : rootPackage; assert filePackage != null : "File package should be already resolved and be found"; JetScope scope = filePackage.getMemberScope(); @@ -390,8 +391,8 @@ public class ResolveElementCache { } for (DeclarationDescriptor descriptor : descriptors) { - if (descriptor instanceof NamespaceDescriptor) { - return ((NamespaceDescriptor) descriptor).getMemberScope(); + if (descriptor instanceof PackageViewDescriptor) { + return ((PackageViewDescriptor) descriptor).getMemberScope(); } } } @@ -403,8 +404,8 @@ public class ResolveElementCache { // Inside package declaration JetNamespaceHeader namespaceHeader = PsiTreeUtil.getParentOfType(expression, JetNamespaceHeader.class, false); if (namespaceHeader != null) { - NamespaceDescriptor packageDescriptor = resolveSession.getPackageDescriptorByFqName( - namespaceHeader.getParentFqName((JetReferenceExpression) expression)); + PackageViewDescriptor packageDescriptor = resolveSession.getModuleDescriptor().getPackage( + namespaceHeader.getParentFqName((JetSimpleNameExpression) expression)); if (packageDescriptor != null) { return packageDescriptor.getMemberScope(); } diff --git a/idea/src/org/jetbrains/jet/plugin/quickfix/CreateFunctionFromUsageFix.java b/idea/src/org/jetbrains/jet/plugin/quickfix/CreateFunctionFromUsageFix.java index c4c03bd59d6..91d5d07b516 100644 --- a/idea/src/org/jetbrains/jet/plugin/quickfix/CreateFunctionFromUsageFix.java +++ b/idea/src/org/jetbrains/jet/plugin/quickfix/CreateFunctionFromUsageFix.java @@ -49,6 +49,7 @@ import com.intellij.util.IncorrectOperationException; import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; +import org.jetbrains.jet.analyzer.AnalyzeExhaust; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.impl.MutableClassDescriptor; import org.jetbrains.jet.lang.diagnostics.*; @@ -56,6 +57,7 @@ import org.jetbrains.jet.lang.psi.*; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingContextUtils; import org.jetbrains.jet.lang.resolve.DescriptorUtils; +import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.types.*; @@ -578,6 +580,7 @@ public class CreateFunctionFromUsageFix extends CreateFromUsageFixBase { private Editor currentFileEditor; private Editor containingFileEditor; private BindingContext currentFileContext; + private ModuleDescriptor currentFileModule; private JetClass ownerClass; private ClassDescriptor ownerClassDescriptor; private TypeCandidate selectedReceiverType; @@ -604,7 +607,9 @@ public class CreateFunctionFromUsageFix extends CreateFromUsageFixBase { public void invoke(@NotNull final Project project, Editor editor, JetFile file) throws IncorrectOperationException { currentFile = file; currentFileEditor = editor; - currentFileContext = AnalyzerFacadeWithCache.analyzeFileWithCache(currentFile).getBindingContext(); + AnalyzeExhaust exhaust = AnalyzerFacadeWithCache.analyzeFileWithCache(currentFile); + currentFileContext = exhaust.getBindingContext(); + currentFileModule = exhaust.getModuleDescriptor(); ownerType.computeTypeCandidates(currentFileContext); List ownerTypeCandidates = ownerType.getTypeCandidates(); @@ -663,9 +668,7 @@ public class CreateFunctionFromUsageFix extends CreateFromUsageFixBase { JetScope scope; if (isExtension) { - NamespaceDescriptor namespaceDescriptor = currentFileContext.get(BindingContext.FILE_TO_NAMESPACE, currentFile); - assert namespaceDescriptor != null; - scope = namespaceDescriptor.getMemberScope(); + scope = currentFileModule.getPackage(JetPsiUtil.getFQName(currentFile)).getMemberScope(); } else { assert ownerClassDescriptor instanceof MutableClassDescriptor; scope = ((MutableClassDescriptor) ownerClassDescriptor).getScopeForMemberResolution(); diff --git a/idea/src/org/jetbrains/jet/plugin/references/BuiltInsReferenceResolver.java b/idea/src/org/jetbrains/jet/plugin/references/BuiltInsReferenceResolver.java index f5100a9a7ca..40eb4b5a4c6 100644 --- a/idea/src/org/jetbrains/jet/plugin/references/BuiltInsReferenceResolver.java +++ b/idea/src/org/jetbrains/jet/plugin/references/BuiltInsReferenceResolver.java @@ -239,7 +239,7 @@ public class BuiltInsReferenceResolver extends AbstractProjectComponent { new ModuleDescriptorImpl(Name.special(""), Collections.emptyList(), PlatformToKotlinClassMap.EMPTY) .setModuleConfiguration(ModuleConfiguration.EMPTY), Collections.emptyList(), Name.special("")), Collections.emptyList(), - KotlinBuiltIns.getInstance().getBuiltInsPackage().getName()); + KotlinBuiltIns.BUILT_INS_PACKAGE_NAME); } void setMemberScope(WritableScope memberScope) { diff --git a/idea/tests/org/jetbrains/jet/plugin/references/BuiltInsReferenceResolverTest.java b/idea/tests/org/jetbrains/jet/plugin/references/BuiltInsReferenceResolverTest.java index fd1e2a347a6..8fe676ffc00 100644 --- a/idea/tests/org/jetbrains/jet/plugin/references/BuiltInsReferenceResolverTest.java +++ b/idea/tests/org/jetbrains/jet/plugin/references/BuiltInsReferenceResolverTest.java @@ -74,7 +74,7 @@ public class BuiltInsReferenceResolverTest extends ResolveTestCase { public void testAllReferencesResolved() { BuiltInsReferenceResolver referenceResolver = getProject().getComponent(BuiltInsReferenceResolver.class); - for (DeclarationDescriptor descriptor : getAllStandardDescriptors(KotlinBuiltIns.getInstance().getBuiltInsPackage())) { + for (DeclarationDescriptor descriptor : getAllStandardDescriptors(KotlinBuiltIns.getInstance().getBuiltInsPackageFragment())) { if (descriptor instanceof NamespaceDescriptor && "jet".equals(descriptor.getName().asString())) continue; assertNotNull("Can't resolve " + descriptor, referenceResolver.resolveBuiltInSymbol(descriptor)); } diff --git a/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java b/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java index aeee5aab156..44e41daa55f 100644 --- a/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java +++ b/js/js.translator/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerForJs.java @@ -28,6 +28,7 @@ import org.jetbrains.jet.lang.resolve.TopDownAnalysisParameters; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.descriptors.ModuleDescriptorImpl; import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolverDummyImpl; +import org.jetbrains.jet.lang.resolve.MutablePackageFragmentProvider; import org.jetbrains.jet.lang.resolve.NamespaceFactoryImpl; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.resolve.DeclarationResolver; @@ -66,6 +67,7 @@ public class InjectorForTopDownAnalyzerForJs { private final BindingTrace bindingTrace; private final ModuleDescriptorImpl moduleDescriptor; private final DependencyClassByQualifiedNameResolverDummyImpl dependencyClassByQualifiedNameResolverDummy; + private final MutablePackageFragmentProvider mutablePackageFragmentProvider; private final NamespaceFactoryImpl namespaceFactory; private final PlatformToKotlinClassMap platformToKotlinClassMap; private final DeclarationResolver declarationResolver; @@ -105,6 +107,7 @@ public class InjectorForTopDownAnalyzerForJs { this.bindingTrace = bindingTrace; this.moduleDescriptor = moduleDescriptor; this.dependencyClassByQualifiedNameResolverDummy = new DependencyClassByQualifiedNameResolverDummyImpl(); + this.mutablePackageFragmentProvider = new MutablePackageFragmentProvider(getModuleDescriptor()); this.namespaceFactory = new NamespaceFactoryImpl(); this.platformToKotlinClassMap = org.jetbrains.jet.lang.PlatformToKotlinClassMap.EMPTY; this.declarationResolver = new DeclarationResolver(); @@ -130,9 +133,9 @@ public class InjectorForTopDownAnalyzerForJs { this.topDownAnalyzer.setContext(topDownAnalysisContext); this.topDownAnalyzer.setDeclarationResolver(declarationResolver); this.topDownAnalyzer.setModuleDescriptor(moduleDescriptor); - this.topDownAnalyzer.setNamespaceFactory(namespaceFactory); this.topDownAnalyzer.setOverloadResolver(overloadResolver); this.topDownAnalyzer.setOverrideResolver(overrideResolver); + this.topDownAnalyzer.setPackageFragmentProvider(mutablePackageFragmentProvider); this.topDownAnalyzer.setTopDownAnalysisParameters(topDownAnalysisParameters); this.topDownAnalyzer.setTrace(bindingTrace); this.topDownAnalyzer.setTypeHierarchyResolver(typeHierarchyResolver); @@ -161,7 +164,8 @@ public class InjectorForTopDownAnalyzerForJs { this.descriptorResolver.setExpressionTypingServices(expressionTypingServices); this.descriptorResolver.setTypeResolver(typeResolver); - namespaceFactory.setModuleDescriptor(moduleDescriptor); + namespaceFactory.setModule(moduleDescriptor); + namespaceFactory.setPackageFragmentProvider(mutablePackageFragmentProvider); namespaceFactory.setTrace(bindingTrace); declarationResolver.setAnnotationResolver(annotationResolver); diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/declaration/NamespaceDeclarationTranslator.java b/js/js.translator/src/org/jetbrains/k2js/translate/declaration/NamespaceDeclarationTranslator.java index 12bc8d4f810..4b04351caf0 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/declaration/NamespaceDeclarationTranslator.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/declaration/NamespaceDeclarationTranslator.java @@ -54,18 +54,19 @@ public final class NamespaceDeclarationTranslator extends AbstractTranslator { NamespaceDescriptor rootNamespaceDescriptor = null; for (JetFile file : files) { - NamespaceDescriptor descriptor = context().bindingContext().get(BindingContext.FILE_TO_NAMESPACE, file); - assert descriptor != null; - NamespaceTranslator translator = descriptorToTranslator.get(descriptor); - if (translator == null) { - if (rootNamespaceDescriptor == null) { - rootNamespaceDescriptor = getRootPackageDescriptor(descriptorToDefineInvocation, descriptor); - } - translator = new NamespaceTranslator(descriptor, descriptorToDefineInvocation, context()); - descriptorToTranslator.put(descriptor, translator); - } - - translator.translate(file); + // TODO 1 + //NamespaceDescriptor descriptor = context().bindingContext().get(BindingContext.FILE_TO_NAMESPACE, file); + //assert descriptor != null; + //NamespaceTranslator translator = descriptorToTranslator.get(descriptor); + //if (translator == null) { + // if (rootNamespaceDescriptor == null) { + // rootNamespaceDescriptor = getRootPackageDescriptor(descriptorToDefineInvocation, descriptor); + // } + // translator = new NamespaceTranslator(descriptor, descriptorToDefineInvocation, context()); + // descriptorToTranslator.put(descriptor, translator); + //} + // + //translator.translate(file); } if (rootNamespaceDescriptor == null) { diff --git a/js/js.translator/src/org/jetbrains/k2js/translate/utils/JsDescriptorUtils.java b/js/js.translator/src/org/jetbrains/k2js/translate/utils/JsDescriptorUtils.java index f3fd0708c3b..7876c88f4ab 100644 --- a/js/js.translator/src/org/jetbrains/k2js/translate/utils/JsDescriptorUtils.java +++ b/js/js.translator/src/org/jetbrains/k2js/translate/utils/JsDescriptorUtils.java @@ -185,7 +185,7 @@ public final class JsDescriptorUtils { @Nullable public static Name getNameIfStandardType(@NotNull JetType type) { ClassifierDescriptor descriptor = type.getConstructor().getDeclarationDescriptor(); - if (descriptor != null && descriptor.getContainingDeclaration() == KotlinBuiltIns.getInstance().getBuiltInsPackage()) { + if (descriptor != null && descriptor.getContainingDeclaration() == KotlinBuiltIns.getInstance().getBuiltInsPackageFragment()) { return descriptor.getName(); }