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

Big refactoring. Migrating to package views and fragments.

Browse Source
This commit is contained in:
Evgeny Gerashchenko
2013-10-11 21:43:40 +04:00
parent 369824cd2e
commit 7abe6a5b4a
141 changed files with 1728 additions and 1465 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorFinder.java
+4 -3
View File
@@ -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<Name> getClassNames(@NotNull FqName packageName);
compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/DescriptorSerializer.java
+8 -2
View File
@@ -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<PackageFragmentDescriptor> fragments) {
ProtoBuf.Package.Builder builder = ProtoBuf.Package.newBuilder();
for (DeclarationDescriptor declaration : sort(descriptor.getMemberScope().getAllDescriptors())) {
Collection<DeclarationDescriptor> 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));
}
compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/NameTable.java
+5 -8
View File
@@ -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) {
compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedMemberScope.java
+1 -1
View File
@@ -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;
}
compiler/frontend/serialization/src/org/jetbrains/jet/descriptors/serialization/descriptors/DeserializedPackageMemberScope.java
+4 -14
View File
@@ -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() {
compiler/frontend/src/org/jetbrains/jet/di/InjectorForTopDownAnalyzerBasic.java
+6 -2
View File
@@ -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);
compiler/frontend/src/org/jetbrains/jet/lang/psi/JetNamespaceHeader.java
+2 -2
View File
@@ -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) {
compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java
+4 -10
View File
@@ -196,8 +196,6 @@ public interface BindingContext {
}
};
WritableSlice<PsiElement, NamespaceDescriptor> NAMESPACE = Slices.<PsiElement, NamespaceDescriptor>sliceBuilder()
.setOpposite((WritableSlice) BindingContextUtils.DESCRIPTOR_TO_DECLARATION).build();
WritableSlice<PsiElement, ClassDescriptor> CLASS =
Slices.<PsiElement, ClassDescriptor>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.<ClassDescriptor, FunctionDescriptor>sliceBuilder().build();
WritableSlice<FqName, ClassDescriptor> FQNAME_TO_CLASS_DESCRIPTOR = new BasicWritableSlice<FqName, ClassDescriptor>(DO_NOTHING, true);
@Deprecated
WritableSlice<FqName, NamespaceDescriptor> FQNAME_TO_NAMESPACE_DESCRIPTOR =
new BasicWritableSlice<FqName, NamespaceDescriptor>(DO_NOTHING);
WritableSlice<JetFile, NamespaceDescriptor> FILE_TO_NAMESPACE = Slices.createSimpleSlice();
WritableSlice<NamespaceDescriptor, Collection<JetFile>> NAMESPACE_TO_FILES = Slices.createSimpleSlice();
/**
* Each namespace found in src must be registered here.
*/
WritableSlice<NamespaceDescriptor, Boolean> NAMESPACE_IS_SRC = Slices.createSimpleSlice();
WritableSlice<JetFile, PackageFragmentDescriptor> FILE_TO_PACKAGE_FRAGMENT = Slices.createSimpleSlice();
WritableSlice<FqName, Collection<JetFile>> PACKAGE_TO_FILES = Slices.createSimpleSlice();
WritableSlice<ClassDescriptor, Boolean> INCOMPLETE_HIERARCHY = Slices.createCollectiveSetSlice();
compiler/frontend/src/org/jetbrains/jet/lang/resolve/DeclarationResolver.java
+16 -14
View File
@@ -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<JetFile, WritableScope> 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<Name, DeclarationDescriptor> simpleNameDescriptors = descriptor.getMemberScope().getDeclaredDescriptorsAccessibleBySimpleName();
for (MutablePackageFragmentDescriptor packageFragment : Sets.newHashSet(context.getPackageFragments().values())) {
PackageViewDescriptor packageView = packageFragment.getContainingDeclaration().getPackage(packageFragment.getFqName());
JetScope packageViewScope = packageView.getMemberScope();
Multimap<Name, DeclarationDescriptor> simpleNameDescriptors = packageFragment.getMemberScope().getDeclaredDescriptorsAccessibleBySimpleName();
for (Name name : simpleNameDescriptors.keySet()) {
// Keep only properties with no receiver
Collection<DeclarationDescriptor> descriptors = Collections2.filter(simpleNameDescriptors.get(name), new Predicate<DeclarationDescriptor>() {
@@ -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<PsiElement> getDeclarationsByDescriptor(DeclarationDescriptor declarationDescriptor) {
Collection<PsiElement> declarations;
if (declarationDescriptor instanceof NamespaceDescriptor) {
final NamespaceDescriptor namespace = (NamespaceDescriptor)declarationDescriptor;
Collection<JetFile> files = trace.get(BindingContext.NAMESPACE_TO_FILES, namespace);
if (declarationDescriptor instanceof PackageViewDescriptor) {
final PackageViewDescriptor aPackage = (PackageViewDescriptor)declarationDescriptor;
Collection<JetFile> 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<JetFile, PsiElement>() {
@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();
}
});
compiler/frontend/src/org/jetbrains/jet/lang/resolve/Importer.java
+4 -4
View File
@@ -88,8 +88,8 @@ public interface Importer {
protected void importAllUnderDeclaration(@NotNull DeclarationDescriptor descriptor, @NotNull PlatformToKotlinClassMap platformToKotlinClassMap) {
List<JetScope> scopesToImport = new ArrayList<JetScope>(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);
compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java
+16 -15
View File
@@ -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<JetImportDirective> directives, JetScope rootScope) {
processImportsInFile(lookupMode, scope, directives, rootScope, moduleDescriptor, trace, qualifiedExpressionResolver, importsFactory);
private void processImportsInFile(@NotNull LookupMode lookupMode, WritableScope scope, List<JetImportDirective> directives) {
processImportsInFile(lookupMode, scope, directives, moduleDescriptor, trace, qualifiedExpressionResolver, importsFactory);
}
public static void processImportsInFile(
private static void processImportsInFile(
LookupMode lookupMode,
@NotNull WritableScope namespaceScope,
@NotNull List<JetImportDirective> 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;
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/ModifiersChecker.java
+1 -1
View File
@@ -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()));
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/MutablePackageFragmentProvider.java
+59
View File
@@ -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<FqName, MutablePackageFragmentDescriptor> fqNameToPackage = Maps.newHashMap();
private final MultiMap<FqName, FqName> subPackages = MultiMap.create();
public MutablePackageFragmentProvider(@NotNull ModuleDescriptor module) {
this.module = module;
fqNameToPackage.put(FqName.ROOT, new MutablePackageFragmentDescriptor(module, FqName.ROOT));
}
@NotNull
@Override
public List<PackageFragmentDescriptor> getPackageFragments(@NotNull FqName fqName) {
return ContainerUtil.<PackageFragmentDescriptor>createMaybeSingletonList(fqNameToPackage.get(fqName));
}
@NotNull
@Override
public Collection<FqName> 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;
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/NamespaceFactory.java
+2 -1
View File
@@ -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);
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/NamespaceFactoryImpl.java
+51 -144
View File
@@ -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<JetSimpleNameExpression> allNamespaceNames = new ArrayList<JetSimpleNameExpression>(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.<AnnotationDescriptor>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<JetFile> 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<JetFile> files = trace.get(PACKAGE_TO_FILES, fqName);
if (files == null) {
files = Sets.newIdentityHashSet();
}
files.add(file);
trace.record(BindingContext.PACKAGE_TO_FILES, fqName, files);
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/OverloadResolver.java
+15 -15
View File
@@ -66,12 +66,12 @@ public class OverloadResolver {
}
private static class Key extends Pair<String, Name> {
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<ClassDescriptor, ConstructorDescriptor> inClasses = MultiMap.create();
MultiMap<Key, ConstructorDescriptor> inNamespaces = MultiMap.create();
MultiMap<Key, ConstructorDescriptor> 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<Key, ConstructorDescriptor> 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);
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/QualifiedExpressionResolver.java
+12 -12
View File
@@ -38,7 +38,7 @@ public class QualifiedExpressionResolver {
private static final Predicate<DeclarationDescriptor> CLASSIFIERS_AND_NAMESPACES = new Predicate<DeclarationDescriptor>() {
@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<SuccessfulLookupResult> 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<DeclarationDescriptor> 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);
compiler/frontend/src/org/jetbrains/jet/lang/resolve/ScriptHeaderResolver.java
+2 -1
View File
@@ -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) {
compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalysisContext.java
+5 -5
View File
@@ -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<JetClassOrObject, MutableClassDescriptor> classes = Maps.newLinkedHashMap();
protected final Map<JetFile, NamespaceDescriptorImpl> namespaceDescriptors = Maps.newHashMap();
protected final Map<JetFile, MutablePackageFragmentDescriptor> packageFragments = Maps.newHashMap();
private List<MutableClassDescriptorLite> classesTopologicalOrder = null;
private final Map<JetDeclaration, JetScope> declaringScopes = Maps.newHashMap();
@@ -114,13 +114,13 @@ public class TopDownAnalysisContext implements BodiesResolveContext {
return namespaceScopes;
}
public Map<JetFile, NamespaceDescriptorImpl> getNamespaceDescriptors() {
return namespaceDescriptors;
public Map<JetFile, MutablePackageFragmentDescriptor> getPackageFragments() {
return packageFragments;
}
@Override
public Collection<JetFile> getFiles() {
return namespaceDescriptors.keySet();
return packageFragments.keySet();
}
@Override
compiler/frontend/src/org/jetbrains/jet/lang/resolve/TopDownAnalyzer.java
+16 -20
View File
@@ -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<JetFile> files) {
ArrayList<JetDeclaration> toAnalyze = new ArrayList<JetDeclaration>();
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<JetFile> files,
@NotNull List<AnalyzerScriptParameter> 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;
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java
+16 -18
View File
@@ -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
compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallExpressionResolver.java
+2 -2
View File
@@ -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;
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/extension/InlineAnalyzerExtension.java
+1 -1
View File
@@ -99,7 +99,7 @@ public class InlineAnalyzerExtension implements FunctionAnalyzerExtension.Analyz
return;
}
if (functionDescriptor.getContainingDeclaration() instanceof NamespaceDescriptor) {
if (functionDescriptor.getContainingDeclaration() instanceof PackageFragmentDescriptor) {
return;
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/KotlinCodeAnalyzer.java
+1 -8
View File
@@ -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);
compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyImportScope.java
+9 -9
View File
@@ -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<JetImportDirective> 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
compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSession.java
+77 -60
View File
@@ -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<FqName, Name> classifierAliases;
private final MemoizedFunctionToNullable<FqName, LazyPackageDescriptor> 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<FqName, LazyPackageDescriptor>() {
@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<PackageFragmentDescriptor> getPackageFragments(@NotNull FqName fqName) {
return ContainerUtil.<PackageFragmentDescriptor>createMaybeSingletonList(getPackageFragment(fqName));
}
@NotNull
@Override
public Collection<FqName> 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<Name> 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<LazyPackageDescriptor> getAllPackages() {
return collectAllPackages(Lists.<LazyPackageDescriptor>newArrayList(), getPackageFragment(FqName.ROOT));
}
@NotNull
private List<LazyPackageDescriptor> collectAllPackages(
@NotNull List<LazyPackageDescriptor> 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<Void, Void>() {
@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);
}
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ResolveSessionUtils.java
+3 -3
View File
@@ -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<ClassDescriptor> descriptors = getClassOrObjectDescriptorsByFqName(packageDescriptor, classInPackagePath,
@@ -84,7 +84,7 @@ public class ResolveSessionUtils {
@NotNull
private static Collection<ClassDescriptor> getClassOrObjectDescriptorsByFqName(
@NotNull NamespaceDescriptor packageDescriptor,
@NotNull PackageViewDescriptor packageDescriptor,
@NotNull FqName path,
boolean includeObjectDeclarations
) {
compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/ScopeProvider.java
+10 -10
View File
@@ -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<ImportPath> defaultImports = resolveSession.getRootModuleDescriptor().getDefaultImports();
List<ImportPath> defaultImports = resolveSession.getModuleDescriptor().getDefaultImports();
Collection<JetImportDirective> 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());
compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyClassMemberScope.java
+2 -1
View File
@@ -329,8 +329,9 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope<LazyClassDescr
result.addAll(getFunctions(Name.identifier("copy")));
}
@Nullable
@Override
public NamespaceDescriptor getNamespace(@NotNull Name name) {
public PackageViewDescriptor getPackage(@NotNull Name name) {
return null;
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyPackageDescriptor.java
+37 -30
View File
@@ -16,49 +16,39 @@
package org.jetbrains.jet.lang.resolve.lazy.descriptors;
import com.google.common.collect.Iterables;
import com.intellij.psi.NavigatablePsiElement;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
import org.jetbrains.annotations.Nullable;
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.NamespaceDescriptorParent;
import org.jetbrains.jet.lang.resolve.BindingContext;
import org.jetbrains.jet.lang.resolve.DescriptorUtils;
import org.jetbrains.jet.lang.descriptors.impl.DeclarationDescriptorImpl;
import org.jetbrains.jet.lang.resolve.lazy.ForceResolveUtil;
import org.jetbrains.jet.lang.resolve.lazy.LazyDescriptor;
import org.jetbrains.jet.lang.resolve.lazy.ResolveSession;
import org.jetbrains.jet.lang.resolve.lazy.declarations.PackageMemberDeclarationProvider;
import org.jetbrains.jet.lang.resolve.name.FqName;
import org.jetbrains.jet.lang.resolve.name.Name;
import org.jetbrains.jet.lang.resolve.scopes.*;
import org.jetbrains.jet.lang.types.TypeSubstitutor;
import java.util.Collections;
public class LazyPackageDescriptor extends AbstractNamespaceDescriptorImpl implements LazyDescriptor, NamespaceDescriptor {
public class LazyPackageDescriptor extends DeclarationDescriptorImpl implements LazyDescriptor, PackageFragmentDescriptor {
private final ModuleDescriptor module;
private final JetScope memberScope;
private final JetScope lazyScope;
private final FqName fqName;
private final PackageMemberDeclarationProvider declarationProvider;
public LazyPackageDescriptor(
@NotNull NamespaceDescriptorParent containingDeclaration,
@NotNull Name name,
@NotNull ModuleDescriptor module,
@NotNull FqName fqName,
@NotNull ResolveSession resolveSession,
@NotNull PackageMemberDeclarationProvider declarationProvider
) {
super(containingDeclaration, Collections.<AnnotationDescriptor>emptyList(), name);
super(Collections.<AnnotationDescriptor>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, D> R accept(DeclarationDescriptorVisitor<R, D> 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;
}
}
compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/descriptors/LazyPackageMemberScope.java
+5 -30
View File
@@ -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<NamespaceDescriptor, PackageMemberDeclarationProvider> {
private final MemoizedFunctionToNullable<Name, NamespaceDescriptor> packageDescriptors;
public class LazyPackageMemberScope extends AbstractLazyMemberScope<PackageFragmentDescriptor, PackageMemberDeclarationProvider> {
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<Name, NamespaceDescriptor>() {
@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<NamespaceDes
@Override
protected void addExtraDescriptors(@NotNull Collection<DeclarationDescriptor> result) {
for (FqName packageFqName : declarationProvider.getAllDeclaredPackages()) {
result.add(getNamespace(packageFqName.shortName()));
}
}
@Override
compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeSelectorUtil.java
+4 -4
View File
@@ -75,12 +75,12 @@ public class JetScopeSelectorUtil {
}
};
public static final ScopeByNameSelector<NamespaceDescriptor> NAMESPACE_SCOPE_SELECTOR =
new ScopeByNameSelector<NamespaceDescriptor>() {
public static final ScopeByNameSelector<PackageViewDescriptor> PACKAGE_SCOPE_SELECTOR =
new ScopeByNameSelector<PackageViewDescriptor>() {
@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);
}
};
compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WriteThroughScope.java
+15 -26
View File
@@ -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<DeclarationDescriptor> allDescriptors;
@@ -62,13 +67,8 @@ public class WriteThroughScope extends WritableScopeWithImports {
checkMayRead();
Set<FunctionDescriptor> 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<VariableDescriptor> 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()) {