Receivers introduced.

compiler/backend/src/org/jetbrains/jet/codegen/intrinsics/IntrinsicMethods.java

@@ -7,7 +7,7 @@ import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiMethod;
 import com.intellij.psi.search.ProjectScope;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.resolve.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.JetStandardClasses;
 import org.jetbrains.jet.lang.types.JetStandardLibrary;
 import org.jetbrains.jet.lang.types.TypeProjection;

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

@@ -3,8 +3,8 @@ package org.jetbrains.jet.lang.resolve.java;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.resolve.JetScope;
-import org.jetbrains.jet.lang.resolve.SubstitutingScope;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.SubstitutingScope;
 import org.jetbrains.jet.lang.types.*;
 
 import java.util.Collections;

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

@@ -5,11 +5,12 @@ import com.google.common.collect.Sets;
 import com.intellij.psi.*;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.resolve.JetScope;
-import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.TypeSubstitutor;
 
 import java.util.Collection;
+import java.util.List;
 import java.util.Map;
 
 /**
@@ -64,6 +65,7 @@ public class JavaClassMembersScope implements JetScope {
         return classifierDescriptor;
     }
 
+    @NotNull
     @Override
     public Collection<DeclarationDescriptor> getAllDescriptors() {
         if (allDescriptors == null) {
@@ -123,7 +125,7 @@ public class JavaClassMembersScope implements JetScope {
             return null;
         }
 
-        return semanticServices.getDescriptorResolver().resolveFieldToVariableDescriptor((ClassDescriptor) containingDeclaration, field);
+        return semanticServices.getDescriptorResolver().resolveFieldToVariableDescriptor(containingDeclaration, field);
     }
 
     @NotNull
@@ -149,7 +151,12 @@ public class JavaClassMembersScope implements JetScope {
 
     @NotNull
     @Override
-    public JetType getThisType() {
-        return null;
+    public ReceiverDescriptor getImplicitReceiver() {
+        throw new UnsupportedOperationException(); // Should never occur, we don't sit in a Java class...
+    }
+
+    @Override
+    public void getImplicitReceiversHierarchy(@NotNull List<ReceiverDescriptor> result) {
+        throw new UnsupportedOperationException(); // Should never occur, we don't sit in a Java class...
     }
 }

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

@@ -4,7 +4,7 @@ import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.lang.JetSemanticServices;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.ImportingStrategy;
-import org.jetbrains.jet.lang.resolve.WritableScope;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 
 /**
  * @author abreslav

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

@@ -4,7 +4,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.AbstractNamespaceDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
-import org.jetbrains.jet.lang.resolve.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 
 import java.util.List;
 

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

@@ -2,7 +2,7 @@ package org.jetbrains.jet.lang.resolve.java;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.resolve.JetScopeImpl;
+import org.jetbrains.jet.lang.resolve.scopes.JetScopeImpl;
 
 /**
  * @author abreslav

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

@@ -2,7 +2,7 @@ package org.jetbrains.jet.lang.descriptors;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.resolve.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.TypeProjection;
 import org.jetbrains.jet.lang.types.TypeSubstitutor;

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

@@ -3,8 +3,8 @@ package org.jetbrains.jet.lang.descriptors;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.resolve.JetScope;
-import org.jetbrains.jet.lang.resolve.SubstitutingScope;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.SubstitutingScope;
 import org.jetbrains.jet.lang.types.*;
 
 import java.util.Collection;

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

@@ -6,6 +6,10 @@ import com.google.common.collect.Maps;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.resolve.*;
+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.resolve.scopes.receivers.ExtensionCallableReceiver;
 import org.jetbrains.jet.lang.types.*;
 
 import java.util.*;
@@ -95,7 +99,7 @@ public class FunctionDescriptorUtil {
         WritableScope parameterScope = new WritableScopeImpl(outerScope, descriptor, new TraceBasedRedeclarationHandler(trace)).setDebugName("Function inner scope");
         JetType receiverType = descriptor.getReceiverType();
         if (receiverType != null) {
-            parameterScope.setThisType(receiverType);
+            parameterScope.setImplicitReceiver(new ExtensionCallableReceiver(descriptor));
         }
         for (TypeParameterDescriptor typeParameter : descriptor.getTypeParameters()) {
             parameterScope.addTypeParameterDescriptor(typeParameter);

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

@@ -3,8 +3,8 @@ package org.jetbrains.jet.lang.descriptors;
 import com.google.common.collect.Lists;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.resolve.JetScope;
-import org.jetbrains.jet.lang.resolve.SubstitutingScope;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.SubstitutingScope;
 import org.jetbrains.jet.lang.types.*;
 
 import java.util.Collection;

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

@@ -6,6 +6,11 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.resolve.*;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.SubstitutingScope;
+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.types.*;
 import org.jetbrains.jet.resolve.DescriptorRenderer;
 
@@ -160,7 +165,7 @@ public class MutableClassDescriptor extends MutableDeclarationDescriptor impleme
                 getName(),
                 typeParameters,
                 supertypes);
-        scopeForMemberResolution.setThisType(getDefaultType());
+        scopeForMemberResolution.setImplicitReceiver(new ClassReceiver(this));
         for (FunctionDescriptor functionDescriptor : constructors.getFunctionDescriptors()) {
             ((ConstructorDescriptorImpl) functionDescriptor).setReturnType(getDefaultType());
         }

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

@@ -2,7 +2,7 @@ package org.jetbrains.jet.lang.descriptors;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.annotations.Annotated;
-import org.jetbrains.jet.lang.resolve.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.NamespaceType;
 
 /**

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

@@ -3,7 +3,7 @@ package org.jetbrains.jet.lang.descriptors;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.resolve.WritableScope;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 
 import java.util.List;
 

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

@@ -3,8 +3,8 @@ 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.JetScope;
-import org.jetbrains.jet.lang.resolve.LazyScopeAdapter;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.LazyScopeAdapter;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.resolve.DescriptorRenderer;
 

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

@@ -2,9 +2,11 @@ package org.jetbrains.jet.lang.resolve;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 
 import java.util.Collection;
+import java.util.List;
 
 /**
  * @author abreslav
@@ -15,8 +17,13 @@ public abstract class AbstractScopeAdapter implements JetScope {
 
     @NotNull
     @Override
-    public JetType getThisType() {
-        return getWorkerScope().getThisType();
+    public ReceiverDescriptor getImplicitReceiver() {
+        return getWorkerScope().getImplicitReceiver();
+    }
+
+    @Override
+    public void getImplicitReceiversHierarchy(@NotNull List<ReceiverDescriptor> result) {
+        getWorkerScope().getImplicitReceiversHierarchy(result);
     }
 
     @NotNull
@@ -62,6 +69,7 @@ public abstract class AbstractScopeAdapter implements JetScope {
         return getWorkerScope().getDeclarationDescriptorForUnqualifiedThis();
     }
 
+    @NotNull
     @Override
     public Collection<DeclarationDescriptor> getAllDescriptors() {
         return getWorkerScope().getAllDescriptors();

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

@@ -18,6 +18,9 @@ import org.jetbrains.jet.lang.diagnostics.*;
 import org.jetbrains.jet.lang.psi.JetDeclaration;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.psi.JetNamespace;
+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 java.util.Collections;
 

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

@@ -10,6 +10,7 @@ import org.jetbrains.jet.lang.psi.JetAnnotationEntry;
 import org.jetbrains.jet.lang.psi.JetExpression;
 import org.jetbrains.jet.lang.psi.JetModifierList;
 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.ErrorUtils;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.JetTypeInferrer;

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

@@ -7,6 +7,7 @@ import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.diagnostics.Diagnostic;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.util.slicedmap.*;
 

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

@@ -10,6 +10,11 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.cfg.JetFlowInformationProvider;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
+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.resolve.scopes.receivers.ClassReceiver;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ExtensionCallableReceiver;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.lexer.JetTokens;
 import org.jetbrains.jet.util.slicedmap.WritableSlice;
@@ -505,7 +510,7 @@ public class BodyResolver {
             constructorScope.addPropertyDescriptorByFieldName("$" + propertyDescriptor.getName(), propertyDescriptor);
         }
 
-        constructorScope.setThisType(descriptor.getContainingDeclaration().getDefaultType());
+        constructorScope.setImplicitReceiver(new ClassReceiver(descriptor.getContainingDeclaration()));
 
         for (ValueParameterDescriptor valueParameterDescriptor : descriptor.getValueParameters()) {
             JetParameter parameter = (JetParameter) context.getTrace().getBindingContext().get(BindingContext.DESCRIPTOR_TO_DECLARATION, valueParameterDescriptor);
@@ -573,7 +578,7 @@ public class BodyResolver {
         }
         JetType receiverType = propertyDescriptor.getReceiverType();
         if (receiverType != null) {
-            result.setThisType(receiverType);
+            result.setImplicitReceiver(new ExtensionCallableReceiver(propertyDescriptor));
         }
         return result;
     }

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

@@ -17,6 +17,9 @@ import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.diagnostics.Errors;
 import org.jetbrains.jet.lang.psi.*;
+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.*;
 import org.jetbrains.jet.lexer.JetTokens;
 

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

@@ -4,6 +4,8 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 
 import java.util.List;
 import java.util.Map;

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

@@ -2,6 +2,7 @@ package org.jetbrains.jet.lang.resolve;
 
 import com.intellij.openapi.project.Project;
 import org.jetbrains.jet.lang.JetSemanticServices;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 
 /**
 * @author abreslav

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

@@ -1,6 +1,7 @@
 package org.jetbrains.jet.lang.resolve;
 
 import org.jetbrains.jet.lang.psi.JetElement;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.NamespaceType;
 
 /**

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

@@ -5,6 +5,8 @@ import com.google.common.collect.Sets;
 import org.jetbrains.jet.lang.JetSemanticServices;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 
 import java.util.Map;
 import java.util.Set;

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

@@ -5,6 +5,8 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.JetSemanticServices;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScope;
 
 import java.util.Collections;
 import java.util.List;

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

@@ -3,6 +3,7 @@ package org.jetbrains.jet.lang.resolve;
 import com.intellij.psi.PsiElement;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler;
 
 import static org.jetbrains.jet.lang.diagnostics.Errors.REDECLARATION;
 

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

@@ -11,6 +11,9 @@ import org.jetbrains.jet.lang.cfg.JetFlowInformationProvider;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
+import org.jetbrains.jet.lang.resolve.scopes.WriteThroughScope;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.lexer.JetTokens;
 

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

@@ -9,6 +9,8 @@ import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.LazyScopeAdapter;
 import org.jetbrains.jet.lang.types.*;
 
 import java.util.ArrayList;

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

@@ -12,9 +12,9 @@ import org.jetbrains.jet.lang.JetSemanticServices;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.*;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.lang.types.inference.ConstraintSystem;
-import org.jetbrains.jet.resolve.DescriptorRenderer;
 
 import java.util.*;
 
@@ -491,7 +491,7 @@ public class CallResolver {
         }
     }
 
-    private <Descriptor extends CallableDescriptor> Function<ValueParameterDescriptor, ValueParameterDescriptor> createMapFunction(Descriptor substitutedFunctionDescriptor) {
+    private <D extends CallableDescriptor> Function<ValueParameterDescriptor, ValueParameterDescriptor> createMapFunction(D substitutedFunctionDescriptor) {
         assert substitutedFunctionDescriptor != null;
         final Map<ValueParameterDescriptor, ValueParameterDescriptor> parameterMap = Maps.newHashMap();
         for (ValueParameterDescriptor valueParameterDescriptor : substitutedFunctionDescriptor.getValueParameters()) {
@@ -506,7 +506,7 @@ public class CallResolver {
         };
     }
 
-    private <Descriptor extends CallableDescriptor> boolean checkReceiver(ResolutionTask<Descriptor> task, TracingStrategy tracing, Descriptor candidate, TemporaryBindingTrace temporaryTrace) {
+    private <D extends CallableDescriptor> boolean checkReceiver(ResolutionTask<D> task, TracingStrategy tracing, D candidate, TemporaryBindingTrace temporaryTrace) {
         if (!checkReceiverAbsence(task, tracing, candidate, temporaryTrace)) return false;
         JetType receiverType = task.getReceiverType();
         JetType candidateReceiverType = candidate.getReceiverType();
@@ -519,7 +519,7 @@ public class CallResolver {
         return true;
     }
 
-    private <Descriptor extends CallableDescriptor> boolean checkReceiverAbsence(ResolutionTask<Descriptor> task, TracingStrategy tracing, Descriptor candidate, TemporaryBindingTrace temporaryTrace) {
+    private <D extends CallableDescriptor> boolean checkReceiverAbsence(ResolutionTask<D> task, TracingStrategy tracing, D candidate, TemporaryBindingTrace temporaryTrace) {
         JetType receiverType = task.getReceiverType();
         JetType candidateReceiverType = candidate.getReceiverType();
         if (receiverType != null) {
@@ -536,26 +536,26 @@ public class CallResolver {
     }
 
     @NotNull
-    private <Descriptor extends CallableDescriptor> OverloadResolutionResult<Descriptor> computeResultAndReportErrors(BindingTrace trace, TracingStrategy tracing, Map<Descriptor, Descriptor> successfulCandidates, Set<Descriptor> failedCandidates, Set<Descriptor> dirtyCandidates, Map<Descriptor, TemporaryBindingTrace> traces) {
+    private <D extends CallableDescriptor> OverloadResolutionResult<D> computeResultAndReportErrors(BindingTrace trace, TracingStrategy tracing, Map<D, D> successfulCandidates, Set<D> failedCandidates, Set<D> dirtyCandidates, Map<D, TemporaryBindingTrace> traces) {
         // TODO : maybe it's better to filter overrides out first, and only then look for the maximally specific
         if (successfulCandidates.size() > 0) {
             if (successfulCandidates.size() != 1) {
-                Map<Descriptor, Descriptor> cleanCandidates = Maps.newLinkedHashMap(successfulCandidates);
+                Map<D, D> cleanCandidates = Maps.newLinkedHashMap(successfulCandidates);
                 cleanCandidates.keySet().removeAll(dirtyCandidates);
                 if (cleanCandidates.isEmpty()) {
                     cleanCandidates = successfulCandidates;
                 }
-                Descriptor maximallySpecific = overloadingConflictResolver.findMaximallySpecific(cleanCandidates, traces, false);
+                D maximallySpecific = overloadingConflictResolver.findMaximallySpecific(cleanCandidates, traces, false);
                 if (maximallySpecific != null) {
                     return OverloadResolutionResult.success(maximallySpecific);
                 }
 
-                Descriptor maximallySpecificGenericsDiscriminated = overloadingConflictResolver.findMaximallySpecific(cleanCandidates, traces, true);
+                D maximallySpecificGenericsDiscriminated = overloadingConflictResolver.findMaximallySpecific(cleanCandidates, traces, true);
                 if (maximallySpecificGenericsDiscriminated != null) {
                     return OverloadResolutionResult.success(maximallySpecificGenericsDiscriminated);
                 }
 
-                Set<Descriptor> noOverrides = filterOverrides(successfulCandidates.keySet());
+                Set<D> noOverrides = filterOverrides(successfulCandidates.keySet());
                 if (dirtyCandidates.isEmpty()) {
 //                    tracing.reportOverallResolutionError(trace, "Overload resolution ambiguity: "
 //                                                                + makeErrorMessageForMultipleDescriptors(noOverrides));
@@ -567,9 +567,9 @@ public class CallResolver {
                 return OverloadResolutionResult.ambiguity(noOverrides);
             }
             else {
-                Map.Entry<Descriptor, Descriptor> entry = successfulCandidates.entrySet().iterator().next();
-                Descriptor functionDescriptor = entry.getKey();
-                Descriptor result = entry.getValue();
+                Map.Entry<D, D> entry = successfulCandidates.entrySet().iterator().next();
+                D functionDescriptor = entry.getKey();
+                D result = entry.getValue();
 
                 TemporaryBindingTrace temporaryTrace = traces.get(functionDescriptor);
                 temporaryTrace.commit();
@@ -578,7 +578,7 @@ public class CallResolver {
         }
         else if (!failedCandidates.isEmpty()) {
             if (failedCandidates.size() != 1) {
-                Set<Descriptor> noOverrides = filterOverrides(failedCandidates);
+                Set<D> noOverrides = filterOverrides(failedCandidates);
                 if (noOverrides.size() != 1) {
 //                    tracing.reportOverallResolutionError(trace, "None of the following functions can be called with the arguments supplied: "
 //                                                                + makeErrorMessageForMultipleDescriptors(noOverrides));
@@ -588,7 +588,7 @@ public class CallResolver {
                 }
                 failedCandidates = noOverrides;
             }
-            Descriptor functionDescriptor = failedCandidates.iterator().next();
+            D functionDescriptor = failedCandidates.iterator().next();
             TemporaryBindingTrace temporaryTrace = traces.get(functionDescriptor);
             temporaryTrace.commit();
             return OverloadResolutionResult.singleFailedCandidate(failedCandidates.iterator().next());
@@ -599,19 +599,11 @@ public class CallResolver {
         }
     }
 
-    private <Descriptor extends CallableDescriptor> StringBuilder makeErrorMessageForMultipleDescriptors(Set<Descriptor> candidates) {
-        StringBuilder stringBuilder = new StringBuilder("\n");
-        for (Descriptor functionDescriptor : candidates) {
-            stringBuilder.append(DescriptorRenderer.TEXT.render(functionDescriptor)).append("\n");
-        }
-        return stringBuilder;
-    }
-
-    private <Descriptor extends CallableDescriptor> Set<Descriptor> filterOverrides(Set<Descriptor> candidateSet) {
-        Set<Descriptor> candidates = Sets.newLinkedHashSet();
+    private <D extends CallableDescriptor> Set<D> filterOverrides(Set<D> candidateSet) {
+        Set<D> candidates = Sets.newLinkedHashSet();
         outerLoop:
-        for (Descriptor me : candidateSet) {
-            for (Descriptor other : candidateSet) {
+        for (D me : candidateSet) {
+            for (D other : candidateSet) {
                 if (OverloadingConflictResolver.overrides(other, me)) {
                     continue outerLoop;
                 }
@@ -719,18 +711,6 @@ public class CallResolver {
         return found;
     }
 
-    private OverloadResolutionResult<FunctionDescriptor> listToOverloadResolutionResult(List<FunctionDescriptor> result) {
-        if (result.isEmpty()) {
-            return OverloadResolutionResult.nameNotFound();
-        }
-        else if (result.size() == 1) {
-            return OverloadResolutionResult.success(result.get(0));
-        }
-        else {
-            return OverloadResolutionResult.ambiguity(result);
-        }
-    }
-
     private boolean findExtensionFunctions(Collection<FunctionDescriptor> candidates, JetType receiverType, List<JetType> parameterTypes, List<FunctionDescriptor> result) {
         boolean found = false;
         for (FunctionDescriptor functionDescriptor : candidates) {
@@ -756,7 +736,6 @@ public class CallResolver {
         return true;
     }
 
-
     private static TaskPrioritizer<FunctionDescriptor> FUNCTION_TASK_PRIORITIZER = new TaskPrioritizer<FunctionDescriptor>() {
 
         @NotNull
@@ -826,7 +805,6 @@ public class CallResolver {
         }
     };
 
-
     private static TaskPrioritizer<VariableDescriptor> PROPERTY_TASK_PRIORITIZER = new TaskPrioritizer<VariableDescriptor>() {
 
         @NotNull

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

@@ -7,7 +7,8 @@ import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
 import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
 import org.jetbrains.jet.lang.psi.Call;
-import org.jetbrains.jet.lang.resolve.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.JetType;
 
 import java.util.Collection;
@@ -59,11 +60,17 @@ import java.util.List;
         return false;
     }
 
-    public List<ResolutionTask<D>> computePrioritizedTasks(JetScope scope, JetType receiverType, Call call, String name) {
+    public List<ResolutionTask<D>> computePrioritizedTasks(@NotNull JetScope scope, @Nullable JetType receiverType, @NotNull Call call, @NotNull String name) {
         List<ResolutionTask<D>> result = Lists.newArrayList();
+        doComputeTasks(scope, receiverType, call, name, result);
+        return result;
+    }
+
+    private void doComputeTasks(JetScope scope, JetType receiverType, Call call, String name, List<ResolutionTask<D>> result) {
+        List<ReceiverDescriptor> receivers = Lists.newArrayList();
+        scope.getImplicitReceiversHierarchy(receivers);
         if (receiverType != null) {
             Collection<D> extensionFunctions = getExtensionsByName(scope, name);
-
             List<D> nonlocals = Lists.newArrayList();
             List<D> locals = Lists.newArrayList();
             //noinspection unchecked,RedundantTypeArguments
@@ -73,6 +80,12 @@ import java.util.List;
 
             addTask(result, receiverType, call, locals);
             addTask(result, null, call, members);
+
+            for (ReceiverDescriptor receiver : receivers) {
+                Collection<D> memberExtensions = getExtensionsByName(receiver.getReceiverType().getMemberScope(), name);
+                addTask(result, receiverType, call, memberExtensions);
+            }
+
             addTask(result, receiverType, call, nonlocals);
         }
         else {
@@ -85,9 +98,12 @@ import java.util.List;
 
             addTask(result, receiverType, call, locals);
 
+            for (ReceiverDescriptor receiver : receivers) {
+                doComputeTasks(scope, receiver.getReceiverType(), call, name, result);
+            }
+
             addTask(result, receiverType, call, nonlocals);
         }
-        return result;
     }
 
     @NotNull

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

@@ -1,12 +1,14 @@
-package org.jetbrains.jet.lang.resolve;
+package org.jetbrains.jet.lang.resolve.scopes;
 
 import com.google.common.collect.Sets;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.lang.resolve.DescriptorUtils;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 
 import java.util.Collection;
 import java.util.Collections;
+import java.util.List;
 
 /**
  * @author abreslav
@@ -69,10 +71,17 @@ public class ChainedScope implements JetScope {
 
     @NotNull
     @Override
-    public JetType getThisType() {
+    public ReceiverDescriptor getImplicitReceiver() {
         throw new UnsupportedOperationException(); // TODO
     }
 
+    @Override
+    public void getImplicitReceiversHierarchy(@NotNull List<ReceiverDescriptor> result) {
+        for (JetScope jetScope : scopeChain) {
+            jetScope.getImplicitReceiversHierarchy(result);
+        }
+    }
+
     @NotNull
     @Override
     public DeclarationDescriptor getContainingDeclaration() {
@@ -115,6 +124,7 @@ public class ChainedScope implements JetScope {
         return null;
     }
 
+    @NotNull
     @Override
     public Collection<DeclarationDescriptor> getAllDescriptors() {
         if (allDescriptors == null) {

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

@@ -1,11 +1,12 @@
-package org.jetbrains.jet.lang.resolve;
+package org.jetbrains.jet.lang.resolve.scopes;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 
 import java.util.Collection;
+import java.util.List;
 
 /**
  * @author abreslav
@@ -15,7 +16,7 @@ public interface JetScope {
         @NotNull
         @Override
         public DeclarationDescriptor getContainingDeclaration() {
-            throw new UnsupportedOperationException(); // TODO
+            throw new UnsupportedOperationException();
         }
 
         @Override
@@ -36,9 +37,6 @@ public interface JetScope {
     @NotNull
     FunctionGroup getFunctionGroup(@NotNull String name);
 
-    @NotNull
-    JetType getThisType();
-
     @NotNull
     DeclarationDescriptor getContainingDeclaration();
 
@@ -55,5 +53,18 @@ public interface JetScope {
     @Nullable
     DeclarationDescriptor getDeclarationDescriptorForUnqualifiedThis();
 
+    @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);
 }

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

@@ -1,6 +1,7 @@
-package org.jetbrains.jet.lang.resolve;
+package org.jetbrains.jet.lang.resolve.scopes;
 
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.resolve.AbstractScopeAdapter;
 
 /**
  * @author abreslav

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

@@ -1,11 +1,12 @@
-package org.jetbrains.jet.lang.resolve;
+package org.jetbrains.jet.lang.resolve.scopes;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.types.*;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 
 import java.util.Collection;
 import java.util.Collections;
+import java.util.List;
 
 /**
 * @author abreslav
@@ -28,8 +29,8 @@ public abstract class JetScopeImpl implements JetScope {
 
     @NotNull
     @Override
-    public JetType getThisType() {
-        return JetStandardClasses.getNothingType();
+    public ReceiverDescriptor getImplicitReceiver() {
+        return ReceiverDescriptor.NO_RECEIVER;
     }
 
     @NotNull
@@ -54,8 +55,13 @@ public abstract class JetScopeImpl implements JetScope {
         return null;
     }
 
+    @NotNull
     @Override
     public Collection<DeclarationDescriptor> getAllDescriptors() {
         return Collections.emptyList();
     }
+
+    @Override
+    public void getImplicitReceiversHierarchy(@NotNull List<ReceiverDescriptor> result) {
+    }
 }

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

@@ -1,6 +1,7 @@
-package org.jetbrains.jet.lang.resolve;
+package org.jetbrains.jet.lang.resolve.scopes;
 
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.resolve.AbstractScopeAdapter;
 import org.jetbrains.jet.lang.types.LazyValue;
 
 /**

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

@@ -1,4 +1,4 @@
-package org.jetbrains.jet.lang.resolve;
+package org.jetbrains.jet.lang.resolve.scopes;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;

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

@@ -1,14 +1,15 @@
-package org.jetbrains.jet.lang.resolve;
+package org.jetbrains.jet.lang.resolve.scopes;
 
 import com.google.common.collect.Maps;
 import com.google.common.collect.Sets;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.TypeSubstitutor;
 
 import java.util.Collection;
+import java.util.List;
 import java.util.Map;
 
 /**
@@ -56,7 +57,12 @@ public class SubstitutingScope implements JetScope {
 
     @NotNull
     @Override
-    public JetType getThisType() {
+    public ReceiverDescriptor getImplicitReceiver() {
+        throw new UnsupportedOperationException(); // TODO
+    }
+
+    @Override
+    public void getImplicitReceiversHierarchy(@NotNull List<ReceiverDescriptor> result) {
         throw new UnsupportedOperationException(); // TODO
     }
 
@@ -109,6 +115,7 @@ public class SubstitutingScope implements JetScope {
         return workerScope.getDeclarationDescriptorForUnqualifiedThis();
     }
 
+    @NotNull
     @Override
     public Collection<DeclarationDescriptor> getAllDescriptors() {
         if (allDescriptors == null) {

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

@@ -1,9 +1,9 @@
-package org.jetbrains.jet.lang.resolve;
+package org.jetbrains.jet.lang.resolve.scopes;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.types.*;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ImplicitReceiverDescriptor;
 
 /**
  * @author abreslav
@@ -30,5 +30,5 @@ public interface WritableScope extends JetScope {
 
     void importScope(@NotNull JetScope imported);
 
-    void setThisType(@NotNull JetType thisType);
+    void setImplicitReceiver(@NotNull ImplicitReceiverDescriptor implicitReceiver);
 }

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

@@ -1,4 +1,4 @@
-package org.jetbrains.jet.lang.resolve;
+package org.jetbrains.jet.lang.resolve.scopes;
 
 import com.google.common.collect.Lists;
 import com.google.common.collect.Maps;
@@ -6,7 +6,9 @@ import com.google.common.collect.Sets;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.lang.resolve.DescriptorUtils;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ImplicitReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 
 import java.util.*;
 
@@ -32,8 +34,9 @@ public class WritableScopeImpl extends WritableScopeWithImports {
 
     @Nullable
     private Map<String, List<DeclarationDescriptor>> labelsToDescriptors;
+
     @Nullable
-    private JetType thisType;
+    private ImplicitReceiverDescriptor implicitReceiver;
 
     private List<VariableDescriptor> variableDescriptors;
 
@@ -67,6 +70,7 @@ public class WritableScopeImpl extends WritableScopeWithImports {
         super.importClassifierAlias(importedClassifierName, classifierDescriptor);
     }
 
+    @NotNull
     @Override
     public Collection<DeclarationDescriptor> getAllDescriptors() {
         if (!allDescriptorsDone) {
@@ -153,12 +157,12 @@ public class WritableScopeImpl extends WritableScopeWithImports {
             return (VariableDescriptor) descriptor;
         }
 
-        if (thisType != null) {
-            VariableDescriptor variable = getThisType().getMemberScope().getVariable(name);
-            if (variable != null) {
-                return variable;
-            }
-        }
+//        if (implicitReceiver != null) {
+//            VariableDescriptor variable = getImplicitReceiver().getMemberScope().getVariable(name);
+//            if (variable != null) {
+//                return variable;
+//            }
+//        }
 
         VariableDescriptor variableDescriptor = getWorkerScope().getVariable(name);
         if (variableDescriptor != null) {
@@ -200,9 +204,9 @@ public class WritableScopeImpl extends WritableScopeWithImports {
             result.addAllFunctions(functionGroup);
         }
         
-        if (thisType != null) {
-            result.addAllFunctions(getThisType().getMemberScope().getFunctionGroup(name));
-        }
+//        if (implicitReceiver != null) {
+//            result.addAllFunctions(getImplicitReceiver().getMemberScope().getFunctionGroup(name));
+//        }
 
         result.addAllFunctions(getWorkerScope().getFunctionGroup(name));
 
@@ -247,11 +251,11 @@ public class WritableScopeImpl extends WritableScopeWithImports {
 
     @NotNull
     @Override
-    public JetType getThisType() {
-        if (thisType == null) {
-            return super.getThisType();
+    public ReceiverDescriptor getImplicitReceiver() {
+        if (implicitReceiver == null) {
+            return super.getImplicitReceiver();
         }
-        return thisType;
+        return implicitReceiver;
     }
 
     @Override
@@ -283,11 +287,19 @@ public class WritableScopeImpl extends WritableScopeWithImports {
     }
 
     @Override
-    public void setThisType(@NotNull JetType thisType) {
-        if (this.thisType != null) {
+    public void setImplicitReceiver(@NotNull ImplicitReceiverDescriptor implicitReceiver) {
+        if (this.implicitReceiver != null) {
             throw new UnsupportedOperationException("Receiver redeclared");
         }
-        this.thisType = thisType;
+        this.implicitReceiver = implicitReceiver;
+    }
+
+    @Override
+    public void getImplicitReceiversHierarchy(@NotNull List<ReceiverDescriptor> result) {
+        if (implicitReceiver != null && implicitReceiver != ReceiverDescriptor.NO_RECEIVER) {
+            result.add(implicitReceiver);
+        }
+        super.getImplicitReceiversHierarchy(result);
     }
 
     @SuppressWarnings({"NullableProblems"})

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

@@ -1,4 +1,4 @@
-package org.jetbrains.jet.lang.resolve;
+package org.jetbrains.jet.lang.resolve.scopes;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -96,7 +96,7 @@ public abstract class WritableScopeWithImports extends JetScopeAdapter implement
 
     public void importClassifierAlias(@NotNull String importedClassifierName, @NotNull ClassifierDescriptor classifierDescriptor) {
         if (currentIndividualImportScope == null) {
-            WritableScopeImpl writableScope = new WritableScopeImpl(JetScope.EMPTY, getContainingDeclaration(), RedeclarationHandler.DO_NOTHING).setDebugName("Individual import scope");
+            WritableScopeImpl writableScope = new WritableScopeImpl(EMPTY, getContainingDeclaration(), RedeclarationHandler.DO_NOTHING).setDebugName("Individual import scope");
             importScope(writableScope);
             currentIndividualImportScope = writableScope;
         }

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

@@ -1,10 +1,11 @@
-package org.jetbrains.jet.lang.resolve;
+package org.jetbrains.jet.lang.resolve.scopes;
 
 import com.google.common.collect.Lists;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
-import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ImplicitReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 
 import java.util.Collection;
 
@@ -40,8 +41,8 @@ public class WriteThroughScope extends WritableScopeWithImports {
 
     @Override
     @NotNull
-    public JetType getThisType() {
-        return writableWorker.getThisType();
+    public ReceiverDescriptor getImplicitReceiver() {
+        return writableWorker.getImplicitReceiver();
     }
 
     @Override
@@ -146,10 +147,11 @@ public class WriteThroughScope extends WritableScopeWithImports {
     }
 
     @Override
-    public void setThisType(@NotNull JetType thisType) {
-        writableWorker.setThisType(thisType);
+    public void setImplicitReceiver(@NotNull ImplicitReceiverDescriptor implicitReceiver) {
+        writableWorker.setImplicitReceiver(implicitReceiver);
     }
 
+    @NotNull
     @Override
     public Collection<DeclarationDescriptor> getAllDescriptors() {
         if (allDescriptors == null) {

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

@@ -0,0 +1,13 @@
+package org.jetbrains.jet.lang.resolve.scopes.receivers;
+
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+
+/**
+ * @author abreslav
+ */
+public class ClassReceiver extends ImplicitReceiverDescriptor {
+
+    public ClassReceiver(ClassDescriptor classDescriptor) {
+        super(classDescriptor, classDescriptor.getDefaultType());
+    }
+}

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

@@ -0,0 +1,22 @@
+package org.jetbrains.jet.lang.resolve.scopes.receivers;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.types.JetType;
+
+/**
+ * @author abreslav
+ */
+public class ExplicitReceiver implements ReceiverDescriptor {
+
+    private final JetType type;
+
+    public ExplicitReceiver(@NotNull JetType type) {
+        this.type = type;
+    }
+
+    @NotNull
+    @Override
+    public JetType getReceiverType() {
+        return type;
+    }
+}

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

@@ -0,0 +1,13 @@
+package org.jetbrains.jet.lang.resolve.scopes.receivers;
+
+import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
+
+/**
+ * @author abreslav
+ */
+public class ExtensionCallableReceiver extends ImplicitReceiverDescriptor {
+
+    public ExtensionCallableReceiver(CallableDescriptor callableDescriptor) {
+        super(callableDescriptor, callableDescriptor.getReceiverType());
+    }
+}

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

@@ -0,0 +1,32 @@
+package org.jetbrains.jet.lang.resolve.scopes.receivers;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.types.JetType;
+
+/**
+ * Describes a "this" receiver
+ *
+ * @author abreslav
+ */
+public abstract class ImplicitReceiverDescriptor implements ReceiverDescriptor {
+    private final JetType receiverType;
+    private final DeclarationDescriptor declarationDescriptor;
+
+    protected ImplicitReceiverDescriptor(DeclarationDescriptor declarationDescriptor, JetType receiverType) {
+        this.receiverType = receiverType;
+        this.declarationDescriptor = declarationDescriptor;
+    }
+
+    @Override
+    @NotNull
+    public JetType getReceiverType() {
+        return receiverType;
+    }
+
+    @NotNull
+    public DeclarationDescriptor getDeclarationDescriptor() {
+        return declarationDescriptor;
+    }
+}
+

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

@@ -0,0 +1,27 @@
+package org.jetbrains.jet.lang.resolve.scopes.receivers;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.types.JetStandardClasses;
+import org.jetbrains.jet.lang.types.JetType;
+
+/**
+ * @author abreslav
+ */
+public interface ReceiverDescriptor {
+
+    ReceiverDescriptor NO_RECEIVER = new ReceiverDescriptor() {
+        @NotNull
+        @Override
+        public JetType getReceiverType() {
+            return JetStandardClasses.getNothingType();
+        }
+
+        @Override
+        public String toString() {
+            return "NO_RECEIVER";
+        }
+    };
+
+    @NotNull
+    JetType getReceiverType();
+}

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

@@ -2,7 +2,7 @@ package org.jetbrains.jet.lang.types;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.resolve.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 
 import java.util.List;
 

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

@@ -3,7 +3,8 @@ package org.jetbrains.jet.lang.types;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.resolve.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 
 import java.util.*;
 
@@ -32,8 +33,12 @@ public class ErrorUtils {
 
         @NotNull
         @Override
-        public JetType getThisType() {
-            return createErrorType("<ERROR TYPE>");
+        public ReceiverDescriptor getImplicitReceiver() {
+            return ReceiverDescriptor.NO_RECEIVER;
+        }
+
+        @Override
+        public void getImplicitReceiversHierarchy(@NotNull List<ReceiverDescriptor> result) {
         }
 
         @NotNull
@@ -64,6 +69,7 @@ public class ErrorUtils {
             return ERROR_CLASS; // TODO : review
         }
 
+        @NotNull
         @Override
         public Collection<DeclarationDescriptor> getAllDescriptors() {
             return Collections.emptyList();

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

@@ -6,7 +6,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.resolve.*;
+import org.jetbrains.jet.lang.resolve.scopes.*;
 
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;

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

@@ -11,6 +11,9 @@ import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.*;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.RedeclarationHandler;
+import org.jetbrains.jet.lang.resolve.scopes.WritableScopeImpl;
 import org.jetbrains.jet.plugin.JetFileType;
 
 import java.io.IOException;

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

@@ -2,7 +2,7 @@ package org.jetbrains.jet.lang.types;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.annotations.Annotated;
-import org.jetbrains.jet.lang.resolve.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 
 import java.util.List;
 

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

@@ -6,7 +6,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotatedImpl;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.resolve.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 
 import java.util.Collections;
 import java.util.Iterator;

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

@@ -23,6 +23,9 @@ import org.jetbrains.jet.lang.resolve.calls.CallResolver;
 import org.jetbrains.jet.lang.resolve.calls.OverloadResolutionResult;
 import org.jetbrains.jet.lang.resolve.constants.*;
 import org.jetbrains.jet.lang.resolve.constants.StringValue;
+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.lexer.JetTokens;
 import org.jetbrains.jet.util.slicedmap.WritableSlice;
 
@@ -891,7 +894,7 @@ public class JetTypeInferrer {
             if (receiverTypeRef != null) {
                 receiverType = context.typeResolver.resolveType(context.scope, receiverTypeRef);
             } else {
-                receiverType = context.scope.getThisType();
+                receiverType = context.scope.getImplicitReceiver().getReceiverType();
             }
 
             FunctionDescriptorImpl functionDescriptor = new FunctionDescriptorImpl(
@@ -1265,7 +1268,7 @@ public class JetTypeInferrer {
                 }
             }
             else {
-                thisType = context.scope.getThisType();
+                thisType = context.scope.getImplicitReceiver().getReceiverType();
 
                 DeclarationDescriptor declarationDescriptorForUnqualifiedThis = context.scope.getDeclarationDescriptorForUnqualifiedThis();
                 if (declarationDescriptorForUnqualifiedThis != null) {

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

@@ -2,7 +2,7 @@ package org.jetbrains.jet.lang.types;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.resolve.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 
 import java.util.List;
 

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

@@ -3,7 +3,7 @@ package org.jetbrains.jet.lang.types;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
-import org.jetbrains.jet.lang.resolve.SubstitutingScope;
+import org.jetbrains.jet.lang.resolve.scopes.SubstitutingScope;
 
 import java.util.ArrayList;
 import java.util.List;

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

@@ -7,8 +7,8 @@ import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
-import org.jetbrains.jet.lang.resolve.ChainedScope;
-import org.jetbrains.jet.lang.resolve.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.ChainedScope;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.util.CommonSuppliers;
 
 import java.util.*;

idea/src/org/jetbrains/jet/plugin/references/JetPsiReference.java

@@ -89,7 +89,7 @@ public abstract class JetPsiReference implements PsiPolyVariantReference {
         JetFile file = (JetFile) getElement().getContainingFile();
         BindingContext bindingContext = AnalyzerFacade.analyzeFileWithCache(file);
         Collection<? extends DeclarationDescriptor> declarationDescriptors = bindingContext.get(AMBIGUOUS_REFERENCE_TARGET, myExpression);
-        assert declarationDescriptors != null;
+        if (declarationDescriptors != null) return ResolveResult.EMPTY_ARRAY;
         ResolveResult[] results = new ResolveResult[declarationDescriptors.size()];
         int i = 0;
         for (DeclarationDescriptor descriptor : declarationDescriptors) {

idea/src/org/jetbrains/jet/plugin/references/JetSimpleNameReference.java

@@ -13,7 +13,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
-import org.jetbrains.jet.lang.resolve.JetScope;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.plugin.AnalyzerFacade;
 import org.jetbrains.jet.resolve.DescriptorRenderer;

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

@@ -17,6 +17,9 @@ import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.*;
 import org.jetbrains.jet.lang.resolve.java.JavaPackageScope;
 import org.jetbrains.jet.lang.resolve.java.JavaSemanticServices;
+import org.jetbrains.jet.lang.resolve.scopes.*;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ExplicitReceiver;
+import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.lexer.JetTokens;
 import org.jetbrains.jet.parsing.JetParsingTest;
@@ -506,8 +509,8 @@ public class JetTypeCheckerTest extends LightDaemonAnalyzerTestCase {
         JetScope scope = new JetScopeAdapter(classDefinitions.BASIC_SCOPE) {
             @NotNull
             @Override
-            public JetType getThisType() {
-                return thisType;
+            public ReceiverDescriptor getImplicitReceiver() {
+                return new ExplicitReceiver(thisType);
             }
         };
         assertType(scope, expression, expectedType);