From e39648774d3c0fada6fd11a6cadf21169c090576 Mon Sep 17 00:00:00 2001 From: Stepan Koltsov Date: Fri, 30 Dec 2011 15:14:14 +0400 Subject: [PATCH 1/5] fix exception, KT-891 --- .../org/jetbrains/jet/lang/resolve/java/JavaPackageScope.java | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaPackageScope.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaPackageScope.java index 1e1c791fc14..f6a377fee65 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaPackageScope.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaPackageScope.java @@ -83,10 +83,10 @@ public class JavaPackageScope extends JetScopeImpl { PsiField field = psiClassForPackage.findFieldByName(name, true); if (field == null) { - return null; + return Collections.emptySet(); } if (!field.hasModifierProperty(PsiModifier.STATIC)) { - return null; + return Collections.emptySet(); } // TODO: cache From 244d390d7107d9709c7b9816a32843abc4120571 Mon Sep 17 00:00:00 2001 From: svtk Date: Fri, 30 Dec 2011 16:17:32 +0400 Subject: [PATCH 2/5] KT-587 Unresolved reference --- .../lang/resolve/TypeHierarchyResolver.java | 22 +++++++------------ .../diagnostics/tests/scopes/kt587.jet | 11 ++++++++++ 2 files changed, 19 insertions(+), 14 deletions(-) create mode 100644 compiler/testData/diagnostics/tests/scopes/kt587.jet 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 57082c51fc0..471a790fecb 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/TypeHierarchyResolver.java @@ -101,9 +101,8 @@ public class TypeHierarchyResolver { visitClassOrObject( klass, (Map) context.getClasses(), - owner, - outerScope, - mutableClassDescriptor); + mutableClassDescriptor + ); owner.addClassifierDescriptor(mutableClassDescriptor); } @@ -126,9 +125,8 @@ public class TypeHierarchyResolver { visitClassOrObject( enumEntry, (Map) context.getClasses(), - classObjectDescriptor, - outerScope, - mutableClassDescriptor); + mutableClassDescriptor + ); classObjectDescriptor.addClassifierDescriptor(mutableClassDescriptor); } } @@ -140,7 +138,7 @@ public class TypeHierarchyResolver { return ClassObjectStatus.NOT_ALLOWED; } }; - visitClassOrObject(declaration, (Map) context.getObjects(), owner, scope, mutableClassDescriptor); + visitClassOrObject(declaration, (Map) context.getObjects(), mutableClassDescriptor); createPrimaryConstructorForObject((JetDeclaration) declaration, mutableClassDescriptor); context.getTrace().record(BindingContext.CLASS, declaration, mutableClassDescriptor); return mutableClassDescriptor; @@ -157,19 +155,18 @@ public class TypeHierarchyResolver { } } - private void visitClassOrObject(@NotNull JetClassOrObject declaration, Map map, NamespaceLike owner, JetScope outerScope, MutableClassDescriptor mutableClassDescriptor) { + private void visitClassOrObject(@NotNull JetClassOrObject declaration, Map map, MutableClassDescriptor mutableClassDescriptor) { mutableClassDescriptor.setName(JetPsiUtil.safeName(declaration.getName())); map.put(declaration, mutableClassDescriptor); -// declaringScopes.put((JetDeclaration) declaration, outerScope); JetScope classScope = mutableClassDescriptor.getScopeForMemberResolution(); - collectNamespacesAndClassifiers(classScope, outerScopeForStatic, mutableClassDescriptor, declaration.getDeclarations()); + JetScope scopeForStatic = declaration instanceof JetObjectDeclaration ? classScope : outerScopeForStatic; + collectNamespacesAndClassifiers(classScope, scopeForStatic, mutableClassDescriptor, declaration.getDeclarations()); } @Override public void visitTypedef(JetTypedef typedef) { -// context.getTrace().getErrorHandler().genericError(typedef.getNode(), "Unsupported [TopDownAnalyzer]"); context.getTrace().report(UNSUPPORTED.on(typedef, "TypeHierarchyResolver")); } @@ -180,11 +177,9 @@ public class TypeHierarchyResolver { NamespaceLike.ClassObjectStatus status = owner.setClassObjectDescriptor(createClassDescriptorForObject(objectDeclaration, owner, outerScopeForStatic)); switch (status) { case DUPLICATE: -// context.getTrace().getErrorHandler().genericError(classObject.getNode(), "Only one class object is allowed per class"); context.getTrace().report(MANY_CLASS_OBJECTS.on(classObject)); break; case NOT_ALLOWED: -// context.getTrace().getErrorHandler().genericError(classObject.getNode(), "A class object is not allowed here"); context.getTrace().report(CLASS_OBJECT_NOT_ALLOWED.on(classObject)); break; } @@ -366,7 +361,6 @@ public class TypeHierarchyResolver { } } if (node != null) { -// context.getTrace().getErrorHandler().genericError(node, "There's a cycle in the inheritance hierarchy for this type"); context.getTrace().report(CYCLIC_INHERITANCE_HIERARCHY.on(node)); } } diff --git a/compiler/testData/diagnostics/tests/scopes/kt587.jet b/compiler/testData/diagnostics/tests/scopes/kt587.jet new file mode 100644 index 00000000000..84d6f4a80a8 --- /dev/null +++ b/compiler/testData/diagnostics/tests/scopes/kt587.jet @@ -0,0 +1,11 @@ +// KT-587 Unresolved reference + +class Main { + class object { + class States() { + class object { + public val N: States = States() // : States unresolved + } + } + } +} \ No newline at end of file From e25446a7087925c57a598fd1c7e333d743635a85 Mon Sep 17 00:00:00 2001 From: svtk Date: Fri, 30 Dec 2011 16:19:10 +0400 Subject: [PATCH 3/5] resolve imports from objects; error "cannot import from"; ClassDescriptorBoundToReceiver added --- .../ClassDescriptorBoundToReceiver.java | 151 ++++++++++++++++++ .../jet/lang/diagnostics/Errors.java | 3 +- .../jet/lang/resolve/DescriptorUtils.java | 29 ++++ .../jet/lang/resolve/ImportsResolver.java | 112 ++++++------- .../resolve/scopes/ScopeBoundToReceiver.java | 36 +++-- .../diagnostics/tests/scopes/Imports.jet | 30 ++-- 6 files changed, 277 insertions(+), 84 deletions(-) create mode 100644 compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptorBoundToReceiver.java diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptorBoundToReceiver.java b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptorBoundToReceiver.java new file mode 100644 index 00000000000..569b0eb237c --- /dev/null +++ b/compiler/frontend/src/org/jetbrains/jet/lang/descriptors/ClassDescriptorBoundToReceiver.java @@ -0,0 +1,151 @@ +package org.jetbrains.jet.lang.descriptors; + +import com.google.common.collect.Sets; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; +import org.jetbrains.jet.lang.resolve.ImportsResolver; +import org.jetbrains.jet.lang.resolve.scopes.JetScope; +import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; +import org.jetbrains.jet.lang.types.JetType; +import org.jetbrains.jet.lang.types.TypeConstructor; +import org.jetbrains.jet.lang.types.TypeProjection; +import org.jetbrains.jet.lang.types.TypeSubstitutor; + +import java.util.Collection; +import java.util.List; +import java.util.Set; + +/** + * @author svtk + */ +public class ClassDescriptorBoundToReceiver implements ClassDescriptor { + + private ClassDescriptor classDescriptor; + private DeclarationDescriptor receiver; + + public ClassDescriptorBoundToReceiver(ClassDescriptor classDescriptor, DeclarationDescriptor receiver) { + this.classDescriptor = classDescriptor; + this.receiver = receiver; + } + + public ClassDescriptor getClassDescriptor() { + return classDescriptor; + } + + public DeclarationDescriptor getReceiver() { + return receiver; + } + + @NotNull + @Override + public JetScope getMemberScope(List typeArguments) { + return classDescriptor.getMemberScope(typeArguments); + } + + @NotNull + @Override + public JetType getSuperclassType() { + return classDescriptor.getSuperclassType(); + } + + @NotNull + @Override + public Set getConstructors() { + return (Set)Sets.newHashSet(ImportsResolver.ImportResolver.addBoundToReceiver((Collection)classDescriptor.getConstructors(), receiver)); + } + + @Override + public ConstructorDescriptor getUnsubstitutedPrimaryConstructor() { + return classDescriptor.getUnsubstitutedPrimaryConstructor(); + } + + @Override + public boolean hasConstructors() { + return classDescriptor.hasConstructors(); + } + + @NotNull + @Override + public DeclarationDescriptor getOriginal() { + return classDescriptor.getOriginal(); + } + + @NotNull + @Override + public DeclarationDescriptor getContainingDeclaration() { + return classDescriptor.getContainingDeclaration(); + } + + @NotNull + @Override + public TypeConstructor getTypeConstructor() { + return classDescriptor.getTypeConstructor(); + } + + @NotNull + @Override + public JetType getDefaultType() { + return classDescriptor.getDefaultType(); + } + + @NotNull + @Override + public ClassDescriptor substitute(TypeSubstitutor substitutor) { + return classDescriptor.substitute(substitutor); + } + + @Override + public R accept(DeclarationDescriptorVisitor visitor, D data) { + return classDescriptor.accept(visitor, data); + } + + @Override + public void acceptVoid(DeclarationDescriptorVisitor visitor) { + classDescriptor.acceptVoid(visitor); + } + + @Override + public JetType getClassObjectType() { + return classDescriptor.getClassObjectType(); + } + + @Override + public boolean isClassObjectAValue() { + return classDescriptor.isClassObjectAValue(); + } + + @NotNull + @Override + public ClassKind getKind() { + return classDescriptor.getKind(); + } + + @NotNull + @Override + public Modality getModality() { + return classDescriptor.getModality(); + } + + @NotNull + @Override + public Visibility getVisibility() { + return classDescriptor.getVisibility(); + } + + @NotNull + @Override + public ReceiverDescriptor getImplicitReceiver() { + return ReceiverDescriptor.NO_RECEIVER; + } + + @Override + public List getAnnotations() { + return classDescriptor.getAnnotations(); + } + + @NotNull + @Override + public String getName() { + return classDescriptor.getName(); + } +} diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java index 5d73a7265d0..22261019d6e 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/diagnostics/Errors.java @@ -83,8 +83,7 @@ public interface Errors { SimpleDiagnosticFactory LABEL_NAME_CLASH = SimpleDiagnosticFactory.create(WARNING, "There is more than one label with such a name in this scope"); SimpleDiagnosticFactory EXPRESSION_EXPECTED_NAMESPACE_FOUND = SimpleDiagnosticFactory.create(ERROR, "Expression expected, but a namespace name found"); - SimpleDiagnosticFactory CANNOT_IMPORT_OBJECT_MEMBERS = SimpleDiagnosticFactory.create(ERROR, "Cannot import members of object separately, use full paths or try to move members to namespace level"); - SimpleDiagnosticFactory CANNOT_IMPORT_VARIABLE_MEMBERS = SimpleDiagnosticFactory.create(ERROR, "Cannot import members of variable separately, use full paths"); + ParameterizedDiagnosticFactory1 CANNOT_IMPORT_FROM_ELEMENT = ParameterizedDiagnosticFactory1.create(ERROR, "Cannot import from ''{0}''", NAME); SimpleDiagnosticFactory CANNOT_INFER_PARAMETER_TYPE = SimpleDiagnosticFactory.create(ERROR, "Cannot infer a type for this parameter. To specify it explicitly use the {(p : Type) => ...} notation"); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java index de4f4a9b0fa..32070cd8d11 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorUtils.java @@ -1,13 +1,17 @@ package org.jetbrains.jet.lang.resolve; +import com.google.common.base.Function; import com.google.common.base.Predicate; import com.google.common.collect.Collections2; import com.google.common.collect.Lists; import com.google.common.collect.Maps; import com.google.common.collect.Sets; +import com.intellij.psi.PsiElement; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; +import org.jetbrains.jet.lang.psi.JetObjectDeclaration; +import org.jetbrains.jet.lang.psi.JetObjectDeclarationName; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.lang.types.*; @@ -211,4 +215,29 @@ public class DescriptorUtils { } return null; } + + @NotNull + public static Function getAddBoundToReceiverFunction(@NotNull final DeclarationDescriptor receiver) { + return new Function() { + @Override + public DeclarationDescriptor apply(@Nullable DeclarationDescriptor descriptor) { + if (descriptor instanceof FunctionDescriptor) { + return new FunctionDescriptorBoundToReceiver((FunctionDescriptor) descriptor, receiver); + } + if (descriptor instanceof VariableDescriptor) { + return new VariableDescriptorBoundToReceiver((VariableDescriptor) descriptor, receiver); + } + if (descriptor instanceof ClassDescriptor) { + return new ClassDescriptorBoundToReceiver((ClassDescriptor) descriptor, receiver); + } + return descriptor; + } + }; + } + + //todo + public static boolean isObjectDescriptor(@NotNull VariableDescriptor descriptor, BindingTrace bindingTrace) { + PsiElement element = bindingTrace.get(BindingContext.DESCRIPTOR_TO_DECLARATION, descriptor); + return element instanceof JetObjectDeclarationName; + } } 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 b2ffb93c2e7..29027eec06c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ImportsResolver.java @@ -1,6 +1,5 @@ package org.jetbrains.jet.lang.resolve; -import com.google.common.base.Function; import com.google.common.collect.Collections2; import com.google.common.collect.Lists; import org.jetbrains.annotations.NotNull; @@ -55,13 +54,10 @@ public class ImportsResolver { public static class ImportResolver { private final BindingTrace trace; private final boolean firstPhase; - // flag is used not to invoke code that resolves members from objects and variables; functionality is under discuss so far, see KT-876 - private final boolean importMembersFromObjectsAndVars; public ImportResolver(BindingTrace trace, boolean firstPhase) { this.trace = trace; this.firstPhase = firstPhase; - this.importMembersFromObjectsAndVars = false; } public void processImportReference(JetImportDirective importDirective, WritableScope namespaceScope, JetScope outerScope) { @@ -82,27 +78,21 @@ public class ImportsResolver { } JetSimpleNameExpression referenceExpression = getLastReference(importedReference); if (importDirective.isAllUnder()) { + if (referenceExpression == null || !canImportMembersFrom(descriptors, referenceExpression)) return; for (DeclarationDescriptor descriptor : descriptors) { if (firstPhase) { if (descriptor instanceof NamespaceDescriptor) { namespaceScope.importScope(((NamespaceDescriptor) descriptor).getMemberScope()); } + continue; } - else if (descriptor instanceof VariableDescriptor) { - if (!importMembersFromObjectsAndVars) { - trace.report(CANNOT_IMPORT_OBJECT_MEMBERS.on(referenceExpression != null ? referenceExpression : importedReference)); - continue; - } + if (descriptor instanceof VariableDescriptor) { JetType type = ((VariableDescriptor) descriptor).getOutType(); if (type != null) { namespaceScope.importScope(ScopeBoundToReceiver.create(descriptor, type.getMemberScope())); } } else if (descriptor instanceof ClassDescriptor) { - if (!importMembersFromObjectsAndVars) { - trace.report(CANNOT_IMPORT_VARIABLE_MEMBERS.on(referenceExpression != null ? referenceExpression : importedReference)); - continue; - } namespaceScope.importScope(ScopeBoundToReceiver.create(descriptor, ((ClassDescriptor) descriptor).getDefaultType().getMemberScope())); } } @@ -120,20 +110,17 @@ public class ImportsResolver { } } - private void importDeclarationAlias(WritableScope namespaceScope, String aliasName, DeclarationDescriptor descriptor) { - if (firstPhase) { - if (descriptor instanceof ClassifierDescriptor) { - namespaceScope.importClassifierAlias(aliasName, (ClassifierDescriptor) descriptor); - } - if (descriptor instanceof NamespaceDescriptor) { - namespaceScope.importNamespaceAlias(aliasName, (NamespaceDescriptor) descriptor); - } - return; + private static void importDeclarationAlias(WritableScope namespaceScope, String aliasName, DeclarationDescriptor descriptor) { + if (descriptor instanceof ClassifierDescriptor) { + namespaceScope.importClassifierAlias(aliasName, (ClassifierDescriptor) descriptor); } - if (descriptor instanceof FunctionDescriptor) { + else if (descriptor instanceof NamespaceDescriptor) { + namespaceScope.importNamespaceAlias(aliasName, (NamespaceDescriptor) descriptor); + } + else if (descriptor instanceof FunctionDescriptor) { namespaceScope.importFunctionAlias(aliasName, (FunctionDescriptor) descriptor); } - if (descriptor instanceof VariableDescriptor) { + else if (descriptor instanceof VariableDescriptor) { namespaceScope.importVariableAlias(aliasName, (VariableDescriptor) descriptor); } } @@ -163,15 +150,16 @@ public class ImportsResolver { JetExpression selectorExpression = importedReference.getSelectorExpression(); assert selectorExpression instanceof JetSimpleNameExpression; JetSimpleNameExpression selector = (JetSimpleNameExpression) selectorExpression; + JetSimpleNameExpression lastReference = getLastReference(receiverExpression); + if (lastReference == null || !canImportMembersFrom(declarationDescriptors, lastReference)) { + return Collections.emptyList(); + } for (DeclarationDescriptor declarationDescriptor : declarationDescriptors) { if (declarationDescriptor instanceof NamespaceDescriptor) { return lookupDescriptorsForSimpleNameReference(selector, ((NamespaceDescriptor) declarationDescriptor).getMemberScope()); } if (declarationDescriptor instanceof ClassDescriptor) { - JetSimpleNameExpression classReference = getLastReference(receiverExpression); - if (classReference != null) { - return lookupObjectMembers(selector, classReference, (ClassDescriptor) declarationDescriptor); - } + return lookupObjectMembers(selector, lastReference, (ClassDescriptor) declarationDescriptor); } if (declarationDescriptor instanceof VariableDescriptor) { return lookupVariableMembers(selector, (VariableDescriptor) declarationDescriptor); @@ -180,52 +168,66 @@ public class ImportsResolver { return Collections.emptyList(); } + private boolean canImportMembersFrom(@NotNull Collection descriptors, @NotNull JetSimpleNameExpression reference) { + if (firstPhase) return true; + if (descriptors.size() == 1) { + return canImportMembersFrom(descriptors.iterator().next(), reference, trace); + } + TemporaryBindingTrace temporaryTrace = TemporaryBindingTrace.create(trace); + boolean canImport = false; + for (DeclarationDescriptor descriptor : descriptors) { + canImport |= canImportMembersFrom(descriptor, reference, temporaryTrace); + } + if (!canImport) { + temporaryTrace.commit(); + } + return canImport; + } + + private boolean canImportMembersFrom(@NotNull DeclarationDescriptor descriptor, @NotNull JetSimpleNameExpression reference, @NotNull BindingTrace trace) { + assert !firstPhase; + if (descriptor instanceof NamespaceDescriptor) { + return true; + } + if (descriptor instanceof ClassDescriptor) { + ClassDescriptor classDescriptor = (ClassDescriptor) descriptor; + JetType classObjectType = classDescriptor.getClassObjectType(); + if (classObjectType == null) { + trace.report(NO_CLASS_OBJECT.on(reference, classDescriptor)); + return false; + } + return true; + } + if (descriptor instanceof VariableDescriptor && DescriptorUtils.isObjectDescriptor((VariableDescriptor) descriptor, trace)) { + return true; + } + trace.report(CANNOT_IMPORT_FROM_ELEMENT.on(reference, descriptor)); + return false; + } + @NotNull private Collection lookupObjectMembers(@NotNull JetSimpleNameExpression memberReference, @NotNull JetSimpleNameExpression classReference, @NotNull ClassDescriptor classDescriptor) { if (firstPhase) return Collections.emptyList(); JetType classObjectType = classDescriptor.getClassObjectType(); - if (classObjectType == null || !classDescriptor.isClassObjectAValue()) { - trace.report(NO_CLASS_OBJECT.on(classReference, classDescriptor)); - return Collections.emptyList(); - } + assert classObjectType != null; Collection members = lookupDescriptorsForSimpleNameReference(memberReference, classObjectType.getMemberScope()); - if (!importMembersFromObjectsAndVars) { - trace.report(CANNOT_IMPORT_OBJECT_MEMBERS.on(memberReference)); - return Collections.emptyList(); - } return addBoundToReceiver(members, classDescriptor); } - @NotNull private Collection lookupVariableMembers(@NotNull JetSimpleNameExpression memberReference, @NotNull VariableDescriptor variableDescriptor) { if (firstPhase) return Collections.emptyList(); JetType variableType = variableDescriptor.getReturnType(); if (variableType == null) return Collections.emptyList(); Collection members = lookupDescriptorsForSimpleNameReference(memberReference, variableType.getMemberScope()); - if (!importMembersFromObjectsAndVars) { - trace.report(CANNOT_IMPORT_VARIABLE_MEMBERS.on(memberReference)); - return Collections.emptyList(); - } return addBoundToReceiver(members, variableDescriptor); } @NotNull - private static Collection addBoundToReceiver(@NotNull Collection descriptors, @NotNull final DeclarationDescriptor implicitReceiver) { - return Collections2.transform(descriptors, new Function() { - @Override - public DeclarationDescriptor apply(@Nullable DeclarationDescriptor descriptor) { - if (descriptor instanceof FunctionDescriptor) { - return new FunctionDescriptorBoundToReceiver((FunctionDescriptor) descriptor, implicitReceiver); - } - if (descriptor instanceof VariableDescriptor) { - return new VariableDescriptorBoundToReceiver((VariableDescriptor) descriptor, implicitReceiver); - } - return descriptor; - } - }); + public static Collection addBoundToReceiver(@NotNull Collection descriptors, @NotNull final DeclarationDescriptor receiver) { + return Collections2.transform(descriptors, DescriptorUtils.getAddBoundToReceiverFunction(receiver)); } - + @NotNull private Collection lookupDescriptorsForSimpleNameReference(@NotNull JetSimpleNameExpression referenceExpression, @NotNull JetScope outerScope) { List descriptors = Lists.newArrayList(); diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/ScopeBoundToReceiver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/ScopeBoundToReceiver.java index 3a1adb599aa..0c475073dc6 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/ScopeBoundToReceiver.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/ScopeBoundToReceiver.java @@ -7,6 +7,7 @@ import com.google.common.collect.SetMultimap; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; +import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor; import org.jetbrains.jet.util.CommonSuppliers; @@ -22,6 +23,7 @@ public class ScopeBoundToReceiver implements JetScope { private SetMultimap propertiesMap; private SetMultimap functionsMap; private Map descriptorsBoundToReceiver; + private Function addBoundToReceiverFunction; public static ScopeBoundToReceiver create(DeclarationDescriptor implicitReceiver, JetScope memberScope) { return new ScopeBoundToReceiver(implicitReceiver, memberScope); @@ -35,7 +37,14 @@ public class ScopeBoundToReceiver implements JetScope { public DeclarationDescriptor getReceiver() { return receiver; } - + + public Function getAddBoundToReceiverFunction() { + if (addBoundToReceiverFunction == null) { + addBoundToReceiverFunction = DescriptorUtils.getAddBoundToReceiverFunction(receiver); + } + return addBoundToReceiverFunction; + } + private SetMultimap getPropertiesMap() { if (propertiesMap == null) { propertiesMap = CommonSuppliers.newLinkedHashSetHashSetMultimap(); @@ -60,7 +69,7 @@ public class ScopeBoundToReceiver implements JetScope { @Nullable @Override public ClassifierDescriptor getClassifier(@NotNull String name) { - return scope.getClassifier(name); + return getMemberBoundToReceiver(scope.getClassifier(name)); } @Nullable @@ -75,12 +84,7 @@ public class ScopeBoundToReceiver implements JetScope { if (getPropertiesMap().containsKey(name)) { return getPropertiesMap().get(name); } - return getMembersBoundToReceiver(name, getPropertiesMap(), scope.getProperties(name), new Function() { - @Override - public VariableDescriptor apply(VariableDescriptor property) { - return new VariableDescriptorBoundToReceiver(property, receiver); - } - }); + return getMembersBoundToReceiver(name, getPropertiesMap(), scope.getProperties(name)); } @Nullable @@ -89,25 +93,25 @@ public class ScopeBoundToReceiver implements JetScope { return scope.getLocalVariable(name); } - private Set getMembersBoundToReceiver(String name, SetMultimap cache, Set oldMembers, Function transformation) { + private Set getMembersBoundToReceiver(String name, SetMultimap cache, Set oldMembers) { for (D oldMember : oldMembers) { - cache.put(name, transformation.apply(oldMember)); + cache.put(name, getMemberBoundToReceiver(oldMember)); } return cache.get(name); } + private D getMemberBoundToReceiver(D oldMember) { + return (D)getAddBoundToReceiverFunction().apply(oldMember); + } + + @NotNull @Override public Set getFunctions(@NotNull String name) { if (getFunctionsMap().containsKey(name)) { return getFunctionsMap().get(name); } - return getMembersBoundToReceiver(name, getFunctionsMap(), scope.getFunctions(name), new Function() { - @Override - public FunctionDescriptor apply(FunctionDescriptor function) { - return new FunctionDescriptorBoundToReceiver(function, receiver); - } - }); + return getMembersBoundToReceiver(name, getFunctionsMap(), scope.getFunctions(name)); } @NotNull diff --git a/compiler/testData/diagnostics/tests/scopes/Imports.jet b/compiler/testData/diagnostics/tests/scopes/Imports.jet index d49e0195b10..02e7ecc6acf 100644 --- a/compiler/testData/diagnostics/tests/scopes/Imports.jet +++ b/compiler/testData/diagnostics/tests/scopes/Imports.jet @@ -5,23 +5,29 @@ import b.B //class import b.foo //function import b.ext //extension function import b.value //property -import b.C.bar //function from class object -import b.C.cValue //property from class object -import b.constant.fff //function from val -import b.constant.dValue //property from val -import b.E.f //val from class object +import b.C.bar //function from class object +import b.C.cValue //property from class object +import b.constant.fff //function from val +import b.constant.dValue //property from val +import b.constant +import b.E.f //val from class object import smth.illegal +import b.C.smth.illegal +import bar.smth +import bar.* fun test(arg: B) { foo(value) arg.ext() - bar() - foo(cValue) + bar() + foo(cValue) fff(dValue) - f.f() + constant.fff(constant.dValue) + + f.f() } // FILE:b.kt @@ -59,17 +65,19 @@ class F() { fun f() {} } +fun bar() {} + //FILE:c.kt package c -import C.* +import C.* object C { fun f() { } - val i = 3 + val i = 348 } fun foo() { - if (i == 3) f() + if (i == 3) f() } \ No newline at end of file From b377d819a432157da9d6512933f213bf668907b2 Mon Sep 17 00:00:00 2001 From: Maxim Shafirov Date: Fri, 30 Dec 2011 16:56:15 +0400 Subject: [PATCH 4/5] Debug module generation on TC build --- .../src/org/jetbrains/jet/compiler/CompileEnvironment.java | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/compiler/backend/src/org/jetbrains/jet/compiler/CompileEnvironment.java b/compiler/backend/src/org/jetbrains/jet/compiler/CompileEnvironment.java index a6a2c41fd8e..544fb6de723 100644 --- a/compiler/backend/src/org/jetbrains/jet/compiler/CompileEnvironment.java +++ b/compiler/backend/src/org/jetbrains/jet/compiler/CompileEnvironment.java @@ -173,6 +173,12 @@ public class CompileEnvironment { return; } + try { + System.out.println("module file text: " + FileUtil.loadFile(new File(moduleFile))); + } catch (Exception e) { + e.printStackTrace(); + } + final String directory = new File(moduleFile).getParent(); for (IModuleBuilder moduleBuilder : moduleSetBuilder.getModules()) { ClassFileFactory moduleFactory = compileModule(moduleBuilder, directory); From 9fd76fbc7726ed0bc21ddf0e95ab5cf5dd9f7184 Mon Sep 17 00:00:00 2001 From: Maxim Shafirov Date: Fri, 30 Dec 2011 16:57:18 +0400 Subject: [PATCH 5/5] We don't support inter-module dependencies yet --- testlib/{src => test}/Test.kt | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename testlib/{src => test}/Test.kt (100%) diff --git a/testlib/src/Test.kt b/testlib/test/Test.kt similarity index 100% rename from testlib/src/Test.kt rename to testlib/test/Test.kt