Migrating scopes onto ReceierParameterDescriptor

Getting rid of getImplicitReceiver() in JetScope

compiler/backend/src/org/jetbrains/jet/cli/jvm/compiler/TipsManager.java

@@ -25,6 +25,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
 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.psi.JetExpression;
 import org.jetbrains.jet.lang.psi.JetImportDirective;
 import org.jetbrains.jet.lang.psi.JetNamespaceHeader;
@@ -104,10 +105,9 @@ public final class TipsManager {
             else {
                 Collection<DeclarationDescriptor> descriptorsSet = Sets.newHashSet();
 
-                List<ReceiverDescriptor> result = new ArrayList<ReceiverDescriptor>();
+                List<ReceiverParameterDescriptor> result = JetScopeUtils.getImplicitReceiversHierarchy(resolutionScope);
-                resolutionScope.getImplicitReceiversHierarchy(result);
 
-                for (ReceiverDescriptor receiverDescriptor : result) {
+                for (ReceiverParameterDescriptor receiverDescriptor : result) {
                     JetType receiverType = receiverDescriptor.getType();
                     descriptorsSet.addAll(receiverType.getMemberScope().getAllDescriptors());
                 }
@@ -153,8 +153,7 @@ public final class TipsManager {
     ) {
         final Set<DeclarationDescriptor> descriptorsSet = Sets.newHashSet(descriptors);
 
-        final List<ReceiverDescriptor> result = new ArrayList<ReceiverDescriptor>();
+        final List<ReceiverParameterDescriptor> result = JetScopeUtils.getImplicitReceiversHierarchy(scope);
-        scope.getImplicitReceiversHierarchy(result);
 
         descriptorsSet.removeAll(
                 Collections2.filter(JetScopeUtils.getAllExtensions(scope), new Predicate<CallableDescriptor>() {
@@ -163,8 +162,8 @@ public final class TipsManager {
                         if (!callableDescriptor.getReceiverParameter().exists()) {
                             return false;
                         }
-                        for (ReceiverDescriptor receiverDescriptor : result) {
+                        for (ReceiverParameterDescriptor receiverDescriptor : result) {
-                            if (ExpressionTypingUtils.checkIsExtensionCallable(receiverDescriptor, callableDescriptor)) {
+                            if (ExpressionTypingUtils.checkIsExtensionCallable(receiverDescriptor.getValue(), callableDescriptor)) {
                                 return false;
                             }
                         }

compiler/frontend/src/org/jetbrains/jet/lang/descriptors/MutableClassDescriptor.java

@@ -28,8 +28,6 @@ import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ClassReceiver;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 
 import java.util.List;
 import java.util.Set;
@@ -155,7 +153,7 @@ public class MutableClassDescriptor extends MutableClassDescriptorLite implement
         for (FunctionDescriptor functionDescriptor : getConstructors()) {
             ((ConstructorDescriptorImpl) functionDescriptor).setReturnType(getDefaultType());
         }
-        scopeForMemberResolution.setImplicitReceiver(new ClassReceiver(this));
+        scopeForMemberResolution.setImplicitReceiver(getThisAsReceiverParameter());
     }
 
     @NotNull
@@ -245,13 +243,12 @@ public class MutableClassDescriptor extends MutableClassDescriptorLite implement
                             return classObjectDescriptor.getDefaultType().getMemberScope();
                         }
 
-                        @NotNull
                         @Override
-                        public ReceiverDescriptor getImplicitReceiver() {
+                        public void getImplicitReceiversHierarchy(@NotNull List<ReceiverParameterDescriptor> result) {
-                            return classObjectDescriptor.getThisAsReceiverParameter();
+                            super.getImplicitReceiversHierarchy(result);
+                            result.add(0, classObjectDescriptor.getThisAsReceiverParameter());
                         }
-                    }
+                    });
-                    );
 
                     return ClassObjectStatus.OK;
                 }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/AbstractScopeAdapter.java

@@ -21,11 +21,9 @@ import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.name.LabelName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 
 import java.util.Collection;
 import java.util.List;
-import java.util.Set;
 
 /**
  * Introduces a simple wrapper for internal scope.
@@ -36,14 +34,8 @@ public abstract class AbstractScopeAdapter implements JetScope {
     @NotNull
     protected abstract JetScope getWorkerScope();
 
-    @NotNull
     @Override
-    public ReceiverDescriptor getImplicitReceiver() {
+    public void getImplicitReceiversHierarchy(@NotNull List<ReceiverParameterDescriptor> result) {
-        return getWorkerScope().getImplicitReceiver();
-    }
-
-    @Override
-    public void getImplicitReceiversHierarchy(@NotNull List<ReceiverDescriptor> result) {
         getWorkerScope().getImplicitReceiversHierarchy(result);
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/DescriptorResolver.java

@@ -33,7 +33,6 @@ import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ClassReceiver;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ExtensionReceiver;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
@@ -742,7 +741,8 @@ public class DescriptorResolver {
             JetType type =
                     getVariableType(scope, variable, dataFlowInfo, false, trace); // For a local variable the type must not be deferred
 
-            propertyDescriptor.setType(type, Collections.<TypeParameterDescriptor>emptyList(), NO_RECEIVER_PARAMETER, (JetType) null);
+            ReceiverParameterDescriptor receiverParameter = ((ScriptDescriptor) containingDeclaration).getThisAsReceiverParameter();
+            propertyDescriptor.setType(type, Collections.<TypeParameterDescriptor>emptyList(), receiverParameter, (JetType) null);
             trace.record(BindingContext.VARIABLE, variable, propertyDescriptor);
             return propertyDescriptor;
         }
@@ -839,7 +839,7 @@ public class DescriptorResolver {
 
     public JetScope getPropertyDeclarationInnerScope(
             @NotNull JetScope outerScope, @NotNull List<? extends TypeParameterDescriptor> typeParameters,
-            @NotNull ReceiverDescriptor receiver, BindingTrace trace
+            @NotNull ReceiverParameterDescriptor receiver, BindingTrace trace
     ) {
         WritableScopeImpl result = new WritableScopeImpl(
                 outerScope, outerScope.getContainingDeclaration(), new TraceBasedRedeclarationHandler(trace),
@@ -908,7 +908,7 @@ public class DescriptorResolver {
 
         ReceiverParameterDescriptor receiverDescriptor = resolveReceiverParameterFor(propertyDescriptor, receiverType);
 
-        JetScope propertyScope = getPropertyDeclarationInnerScope(scope, typeParameterDescriptors, ReceiverDescriptor.NO_RECEIVER, trace);
+        JetScope propertyScope = getPropertyDeclarationInnerScope(scope, typeParameterDescriptors, NO_RECEIVER_PARAMETER, trace);
 
         JetType type = getVariableType(propertyScope, property, DataFlowInfo.EMPTY, true, trace);
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/TaskPrioritizer.java

@@ -30,6 +30,7 @@ import org.jetbrains.jet.lang.resolve.calls.BasicResolutionContext;
 import org.jetbrains.jet.lang.resolve.calls.autocasts.AutoCastServiceImpl;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.JetScopeUtils;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ClassReceiver;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
@@ -114,8 +115,7 @@ public abstract class TaskPrioritizer {
         ProgressIndicatorProvider.checkCanceled();
 
         AutoCastServiceImpl autoCastService = new AutoCastServiceImpl(context.dataFlowInfo, context.trace.getBindingContext());
-        List<ReceiverDescriptor> implicitReceivers = Lists.newArrayList();
+        List<ReceiverDescriptor> implicitReceivers = JetScopeUtils.getImplicitReceiversHierarchyValues(scope);
-        scope.getImplicitReceiversHierarchy(implicitReceivers);
         boolean hasExplicitThisObject = context.call.getThisObject().exists();
         if (hasExplicitThisObject) {
             implicitReceivers.add(context.call.getThisObject());
@@ -226,12 +226,11 @@ public abstract class TaskPrioritizer {
     private static <D extends CallableDescriptor> boolean setImpliedThis(@NotNull JetScope scope, ResolutionCandidate<D> candidate) {
         ReceiverParameterDescriptor expectedThisObject = candidate.getDescriptor().getExpectedThisObject();
         if (!expectedThisObject.exists()) return true;
-        List<ReceiverDescriptor> receivers = Lists.newArrayList();
+        List<ReceiverParameterDescriptor> receivers = JetScopeUtils.getImplicitReceiversHierarchy(scope);
-        scope.getImplicitReceiversHierarchy(receivers);
+        for (ReceiverParameterDescriptor receiver : receivers) {
-        for (ReceiverDescriptor receiver : receivers) {
             if (JetTypeChecker.INSTANCE.isSubtypeOf(receiver.getType(), expectedThisObject.getType())) {
                 // TODO : Autocasts & nullability
-                candidate.setThisObject(expectedThisObject);
+                candidate.setThisObject(expectedThisObject.getValue());
                 return true;
             }
         }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/AbstractLazyMemberScope.java

@@ -27,7 +27,6 @@ import org.jetbrains.jet.lang.resolve.lazy.data.JetClassInfoUtil;
 import org.jetbrains.jet.lang.resolve.name.LabelName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 
 import java.util.*;
 
@@ -262,13 +261,16 @@ public abstract class AbstractLazyMemberScope<D extends DeclarationDescriptor, D
     protected abstract void addExtraDescriptors();
 
     @Override
-    public void getImplicitReceiversHierarchy(@NotNull List<ReceiverDescriptor> result) {
+    public void getImplicitReceiversHierarchy(@NotNull List<ReceiverParameterDescriptor> result) {
-        ReceiverDescriptor receiver = getImplicitReceiver();
+        ReceiverParameterDescriptor receiver = getImplicitReceiver();
         if (receiver.exists()) {
             result.add(receiver);
         }
     }
 
+    @NotNull
+    protected abstract ReceiverParameterDescriptor getImplicitReceiver();
+
     // Do not change this, override in concrete subclasses:
     // it is very easy to compromise laziness of this class, and fail all the debugging
     // a generic implementation can't do this properly

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyClassDescriptor.java

@@ -152,8 +152,7 @@ public class LazyClassDescriptor extends ClassDescriptorBase implements LazyDesc
             scope.addLabeledDeclaration(this);
             scope.changeLockLevel(WritableScope.LockLevel.READING);
 
-            scopeForMemberDeclarationResolution = new ChainedScope(this, getScopeForMemberLookup().getImplicitReceiver(),
+            scopeForMemberDeclarationResolution = new ChainedScope(this, scope, getScopeForMemberLookup(), getScopeForClassHeaderResolution());
-                                                                   scope, getScopeForMemberLookup(), getScopeForClassHeaderResolution());
         }
         return scopeForMemberDeclarationResolution;
     }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyClassMemberScope.java

@@ -27,7 +27,6 @@ import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.lazy.data.JetClassLikeInfo;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.DeferredType;
 import org.jetbrains.jet.lang.types.ErrorUtils;
 import org.jetbrains.jet.lang.types.JetType;
@@ -323,7 +322,7 @@ public class LazyClassMemberScope extends AbstractLazyMemberScope<LazyClassDescr
 
     @NotNull
     @Override
-    public ReceiverDescriptor getImplicitReceiver() {
+    protected ReceiverParameterDescriptor getImplicitReceiver() {
         return thisDescriptor.getThisAsReceiverParameter();
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/lazy/LazyPackageMemberScope.java

@@ -18,17 +18,13 @@ package org.jetbrains.jet.lang.resolve.lazy;
 
 import com.google.common.collect.Maps;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.ClassifierDescriptor;
+import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
-import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
-import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
 import org.jetbrains.jet.lang.psi.JetDeclaration;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 
 import java.util.Map;
 import java.util.Set;
@@ -81,8 +77,8 @@ public class LazyPackageMemberScope extends AbstractLazyMemberScope<NamespaceDes
 
     @NotNull
     @Override
-    public ReceiverDescriptor getImplicitReceiver() {
+    protected ReceiverParameterDescriptor getImplicitReceiver() {
-        return ReceiverDescriptor.NO_RECEIVER;
+        return ReceiverParameterDescriptor.NO_RECEIVER_PARAMETER;
     }
 
     @Override

compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/ChainedScope.java

@@ -21,7 +21,6 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.name.LabelName;
 import org.jetbrains.jet.lang.resolve.name.Name;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 
 import java.util.Collection;
 import java.util.Collections;
@@ -33,17 +32,11 @@ import java.util.Set;
  */
 public class ChainedScope implements JetScope {
     private final DeclarationDescriptor containingDeclaration;
-    private final ReceiverDescriptor implicitReceiver;
     private final JetScope[] scopeChain;
     private Collection<DeclarationDescriptor> allDescriptors;
 
     public ChainedScope(DeclarationDescriptor containingDeclaration, JetScope... scopes) {
-        this(containingDeclaration, ReceiverDescriptor.NO_RECEIVER, scopes);
-    }
-
-    public ChainedScope(DeclarationDescriptor containingDeclaration, ReceiverDescriptor implicitReceiver, JetScope... scopes) {
         this.containingDeclaration = containingDeclaration;
-        this.implicitReceiver = implicitReceiver;
         scopeChain = scopes.clone();
     }
 
@@ -121,14 +114,8 @@ public class ChainedScope implements JetScope {
         return result;
     }
 
-    @NotNull
     @Override
-    public ReceiverDescriptor getImplicitReceiver() {
+    public void getImplicitReceiversHierarchy(@NotNull List<ReceiverParameterDescriptor> result) {
-        return implicitReceiver;
-    }
-
-    @Override
-    public void getImplicitReceiversHierarchy(@NotNull List<ReceiverDescriptor> result) {
         for (JetScope jetScope : scopeChain) {
             jetScope.getImplicitReceiversHierarchy(result);
         }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/InnerClassesScopeWrapper.java

@@ -23,10 +23,10 @@ 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.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.ReceiverParameterDescriptor;
 import org.jetbrains.jet.lang.resolve.AbstractScopeAdapter;
 import org.jetbrains.jet.lang.resolve.name.LabelName;
 import org.jetbrains.jet.lang.resolve.name.Name;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 
 import java.util.Collection;
 import java.util.List;
@@ -82,14 +82,8 @@ public class InnerClassesScopeWrapper extends AbstractScopeAdapter {
         });
     }
 
-    @NotNull
     @Override
-    public ReceiverDescriptor getImplicitReceiver() {
+    public void getImplicitReceiversHierarchy(@NotNull List<ReceiverParameterDescriptor> result) {
-        return ReceiverDescriptor.NO_RECEIVER;
-    }
-
-    @Override
-    public void getImplicitReceiversHierarchy(@NotNull List<ReceiverDescriptor> result) {
         // Do nothing
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScope.java

@@ -21,11 +21,9 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.name.LabelName;
 import org.jetbrains.jet.lang.resolve.name.Name;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 
 import java.util.Collection;
 import java.util.List;
-import java.util.Set;
 
 /**
  * @author abreslav
@@ -86,17 +84,11 @@ public interface JetScope {
     @NotNull
     Collection<DeclarationDescriptor> getAllDescriptors();
 
-    /**
-     * @return EFFECTIVE implicit receiver at this point (may be corresponding to an outer scope)
-     */
-    @NotNull
-    ReceiverDescriptor getImplicitReceiver();
-
     /**
      * Adds receivers to the list in order of locality, so that the closest (the most local) receiver goes first
      * @param result
      */
-    void getImplicitReceiversHierarchy(@NotNull List<ReceiverDescriptor> result);
+    void getImplicitReceiversHierarchy(@NotNull List<ReceiverParameterDescriptor> result);
 
     @NotNull
     Collection<DeclarationDescriptor> getOwnDeclaredDescriptors();

compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeImpl.java

@@ -20,7 +20,6 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.name.LabelName;
 import org.jetbrains.jet.lang.resolve.name.Name;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 
 import java.util.Collection;
 import java.util.Collections;
@@ -63,12 +62,6 @@ public abstract class JetScopeImpl implements JetScope {
         return null;
     }
 
-    @NotNull
-    @Override
-    public ReceiverDescriptor getImplicitReceiver() {
-        return ReceiverDescriptor.NO_RECEIVER;
-    }
-
     @NotNull
     @Override
     public Collection<FunctionDescriptor> getFunctions(@NotNull Name name) {
@@ -93,7 +86,7 @@ public abstract class JetScopeImpl implements JetScope {
     }
 
     @Override
-    public void getImplicitReceiversHierarchy(@NotNull List<ReceiverDescriptor> result) {
+    public void getImplicitReceiversHierarchy(@NotNull List<ReceiverParameterDescriptor> result) {
     }
 
     @NotNull

compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/JetScopeUtils.java

@@ -16,11 +16,14 @@
 
 package org.jetbrains.jet.lang.resolve.scopes;
 
+import com.google.common.base.Function;
+import com.google.common.collect.Collections2;
 import com.google.common.collect.Lists;
 import com.google.common.collect.Sets;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.ReceiverParameterDescriptor;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 
 import java.util.Collection;
@@ -41,12 +44,26 @@ public final class JetScopeUtils {
      * @return receivers hierarchy.
      */
     @NotNull
-    public static Collection<ReceiverDescriptor> getImplicitReceiversHierarchy(@NotNull JetScope scope) {
+    public static List<ReceiverParameterDescriptor> getImplicitReceiversHierarchy(@NotNull JetScope scope) {
-        List<ReceiverDescriptor> descriptors = Lists.newArrayList();
+        List<ReceiverParameterDescriptor> descriptors = Lists.newArrayList();
         scope.getImplicitReceiversHierarchy(descriptors);
         return descriptors;
     }
 
+    public static List<ReceiverDescriptor> getImplicitReceiversHierarchyValues(@NotNull JetScope scope) {
+        Collection<ReceiverParameterDescriptor> hierarchy = getImplicitReceiversHierarchy(scope);
+
+        return Lists.newArrayList(
+                Collections2.transform(hierarchy,
+                       new Function<ReceiverParameterDescriptor, ReceiverDescriptor>() {
+                           @Override
+                           public ReceiverDescriptor apply(ReceiverParameterDescriptor receiverParameterDescriptor) {
+                               return receiverParameterDescriptor.getValue();
+                           }
+                       })
+        );
+    }
+
     /**
      * Get all extension descriptors among visible descriptors for current scope.
      *

compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/SubstitutingScope.java

@@ -23,7 +23,6 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.name.LabelName;
 import org.jetbrains.jet.lang.resolve.name.Name;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.TypeSubstitutor;
 
 import java.util.Collection;
@@ -119,14 +118,8 @@ public class SubstitutingScope implements JetScope {
         return workerScope.getNamespace(name); // TODO
     }
 
-    @NotNull
     @Override
-    public ReceiverDescriptor getImplicitReceiver() {
+    public void getImplicitReceiversHierarchy(@NotNull List<ReceiverParameterDescriptor> result) {
-        throw new UnsupportedOperationException(); // TODO
-    }
-
-    @Override
-    public void getImplicitReceiversHierarchy(@NotNull List<ReceiverDescriptor> result) {
         throw new UnsupportedOperationException(); // TODO
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScope.java

@@ -21,7 +21,6 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.name.Name;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 
 /**
  * @author abreslav
@@ -66,7 +65,7 @@ public interface WritableScope extends JetScope {
 
     void importScope(@NotNull JetScope imported);
 
-    void setImplicitReceiver(@NotNull ReceiverDescriptor implicitReceiver);
+    void setImplicitReceiver(@NotNull ReceiverParameterDescriptor implicitReceiver);
 
     void importClassifierAlias(@NotNull Name importedClassifierName, @NotNull ClassifierDescriptor classifierDescriptor);
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeImpl.java

@@ -22,7 +22,6 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.name.LabelName;
 import org.jetbrains.jet.lang.resolve.name.Name;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
 import org.jetbrains.jet.util.CommonSuppliers;
 
@@ -63,7 +62,7 @@ public class WritableScopeImpl extends WritableScopeWithImports {
     private Map<Name, ClassDescriptor> objectDescriptors;
 
     @Nullable
-    private ReceiverDescriptor implicitReceiver;
+    private ReceiverParameterDescriptor implicitReceiver;
 
     public WritableScopeImpl(@NotNull JetScope scope, @NotNull DeclarationDescriptor owner,
             @NotNull RedeclarationHandler redeclarationHandler, @NotNull String debugName) {
@@ -452,19 +451,8 @@ public class WritableScopeImpl extends WritableScopeWithImports {
         return super.getNamespace(name);
     }
 
-    @NotNull
     @Override
-    public ReceiverDescriptor getImplicitReceiver() {
+    public void setImplicitReceiver(@NotNull ReceiverParameterDescriptor implicitReceiver) {
-        checkMayRead();
-
-        if (implicitReceiver == null) {
-            return super.getImplicitReceiver();
-        }
-        return implicitReceiver;
-    }
-
-    @Override
-    public void setImplicitReceiver(@NotNull ReceiverDescriptor implicitReceiver) {
         checkMayWrite();
 
         if (this.implicitReceiver != null) {
@@ -474,7 +462,7 @@ public class WritableScopeImpl extends WritableScopeWithImports {
     }
 
     @Override
-    public void getImplicitReceiversHierarchy(@NotNull List<ReceiverDescriptor> result) {
+    public void getImplicitReceiversHierarchy(@NotNull List<ReceiverParameterDescriptor> result) {
         checkMayRead();
 
         super.getImplicitReceiversHierarchy(result);

compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WritableScopeWithImports.java

@@ -21,7 +21,6 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.name.Name;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 
 import java.util.ArrayList;
 import java.util.Collection;
@@ -103,7 +102,7 @@ public abstract class WritableScopeWithImports extends JetScopeAdapter implement
     }
 
     @Override
-    public void getImplicitReceiversHierarchy(@NotNull List<ReceiverDescriptor> result) {
+    public void getImplicitReceiversHierarchy(@NotNull List<ReceiverParameterDescriptor> result) {
         checkMayRead();
 
         super.getImplicitReceiversHierarchy(result);
@@ -111,10 +110,7 @@ public abstract class WritableScopeWithImports extends JetScopeAdapter implement
         // Example: class member resolution scope imports a scope of it's class object
         //          members of the class object must be able to find it as an implicit receiver
         for (JetScope scope : getImports()) {
-            ReceiverDescriptor definedReceiver = scope.getImplicitReceiver();
+            scope.getImplicitReceiversHierarchy(result);
-            if (definedReceiver.exists()) {
-                result.add(0, definedReceiver);
-            }
         }
     }
 

compiler/frontend/src/org/jetbrains/jet/lang/resolve/scopes/WriteThroughScope.java

@@ -24,7 +24,6 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.resolve.name.LabelName;
 import org.jetbrains.jet.lang.resolve.name.Name;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 
 import java.util.Collection;
 import java.util.Set;
@@ -66,14 +65,6 @@ public class WriteThroughScope extends WritableScopeWithImports {
         return writableWorker.getContainingDeclaration();
     }
 
-    @Override
-    @NotNull
-    public ReceiverDescriptor getImplicitReceiver() {
-        checkMayRead();
-
-        return writableWorker.getImplicitReceiver();
-    }
-
     @Override
     @NotNull
     public Collection<FunctionDescriptor> getFunctions(@NotNull Name name) {
@@ -275,7 +266,7 @@ public class WriteThroughScope extends WritableScopeWithImports {
     }
 
     @Override
-    public void setImplicitReceiver(@NotNull ReceiverDescriptor implicitReceiver) {
+    public void setImplicitReceiver(@NotNull ReceiverParameterDescriptor implicitReceiver) {
         checkMayWrite();
 
         writableWorker.setImplicitReceiver(implicitReceiver);

compiler/frontend/src/org/jetbrains/jet/lang/types/ErrorUtils.java

@@ -23,7 +23,6 @@ import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.resolve.name.LabelName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.error.ErrorSimpleFunctionDescriptorImpl;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 
@@ -77,14 +76,8 @@ public class ErrorUtils {
             return null; // TODO : review
         }
 
-        @NotNull
         @Override
-        public ReceiverDescriptor getImplicitReceiver() {
+        public void getImplicitReceiversHierarchy(@NotNull List<ReceiverParameterDescriptor> result) {
-            return ReceiverDescriptor.NO_RECEIVER;
-        }
-
-        @Override
-        public void getImplicitReceiversHierarchy(@NotNull List<ReceiverDescriptor> result) {
         }
 
         @NotNull

compiler/frontend/src/org/jetbrains/jet/lang/types/expressions/BasicExpressionTypingVisitor.java

@@ -42,11 +42,10 @@ import org.jetbrains.jet.lang.resolve.constants.StringValue;
 import org.jetbrains.jet.lang.resolve.name.LabelName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.JetScopeUtils;
 import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ClassReceiver;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ExpressionReceiver;
 import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ThisReceiverDescriptor;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.lang.types.checker.JetTypeChecker;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
@@ -400,7 +399,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
     @Override
     public JetTypeInfo visitThisExpression(JetThisExpression expression, ExpressionTypingContext context) {
         JetType result = null;
-        ReceiverDescriptor thisReceiver = resolveToReceiver(expression, context, false);
+        ReceiverParameterDescriptor thisReceiver = resolveToReceiver(expression, context, false);
 
         if (thisReceiver != null) {
             if (!thisReceiver.exists()) {
@@ -422,7 +421,7 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
         }
         JetType result = null;
 
-        ReceiverDescriptor thisReceiver = resolveToReceiver(expression, context, true);
+        ReceiverParameterDescriptor thisReceiver = resolveToReceiver(expression, context, true);
         if (thisReceiver == null) return JetTypeInfo.create(null, context.dataFlowInfo);
 
         if (!thisReceiver.exists()) {
@@ -512,21 +511,23 @@ public class BasicExpressionTypingVisitor extends ExpressionTypingVisitor {
                     expression.getInstanceReference(), expression.getTargetLabel(), context, thisReceiver, new LabelName(labelName));
         }
         else {
+            List<ReceiverParameterDescriptor> receivers = JetScopeUtils.getImplicitReceiversHierarchy(context.scope);
             if (onlyClassReceivers) {
-                List<ReceiverDescriptor> receivers = Lists.newArrayList();
+                for (ReceiverParameterDescriptor receiver : receivers) {
-                context.scope.getImplicitReceiversHierarchy(receivers);
+                    if (receiver.getContainingDeclaration() instanceof ClassDescriptor) {
-                for (ReceiverDescriptor receiver : receivers) {
-                    if (receiver instanceof ClassReceiver) {
                         thisReceiver = receiver;
                         break;
                     }
                 }
             }
-            else {
+            else if (!receivers.isEmpty()) {
-                thisReceiver = context.scope.getImplicitReceiver();
+                thisReceiver = receivers.get(0);
             }
-            if (thisReceiver instanceof ThisReceiverDescriptor) {
+            else {
-                context.trace.record(REFERENCE_TARGET, expression.getInstanceReference(), ((ThisReceiverDescriptor) thisReceiver).getDeclarationDescriptor());
+                thisReceiver = ReceiverParameterDescriptor.NO_RECEIVER_PARAMETER;
+            }
+            if (thisReceiver != null && thisReceiver.exists()) {
+                context.trace.record(REFERENCE_TARGET, expression.getInstanceReference(), thisReceiver.getContainingDeclaration());
             }
         }
         return thisReceiver;

compiler/tests/org/jetbrains/jet/types/JetTypeCheckerTest.java

@@ -37,7 +37,6 @@ 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.resolve.scopes.receivers.ExpressionReceiver;
-import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.CommonSupertypes;
 import org.jetbrains.jet.lang.types.ErrorUtils;
 import org.jetbrains.jet.lang.types.JetType;
@@ -572,10 +571,13 @@ public class JetTypeCheckerTest extends JetLiteFixture {
     private void assertType(String contextType, final String expression, String expectedType) {
         final JetType thisType = makeType(contextType);
         JetScope scope = new JetScopeAdapter(classDefinitions.BASIC_SCOPE) {
-            @NotNull
             @Override
-            public ReceiverDescriptor getImplicitReceiver() {
+            public void getImplicitReceiversHierarchy(@NotNull List<ReceiverParameterDescriptor> result) {
-                return new ExpressionReceiver(JetPsiFactory.createExpression(getProject(), expression), thisType);
+                result.add(new ReceiverParameterDescriptorImpl(
+                        classDefinitions.BASIC_SCOPE.getContainingDeclaration(),
+                        thisType,
+                        new ExpressionReceiver(JetPsiFactory.createExpression(getProject(), expression), thisType)
+                ));
             }
         };
         assertType(scope, expression, expectedType);