diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java
index 7e577956fc3..50edcb51b7e 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java
@@ -45,7 +45,6 @@ import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingContext;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingUtils;
-import org.jetbrains.jet.lang.types.expressions.LabelResolver;
 import org.jetbrains.jet.lexer.JetTokens;
 
 import javax.inject.Inject;
@@ -111,8 +110,7 @@ public class CallResolver {
         List<ResolutionTask<VariableDescriptor, VariableDescriptor>> prioritizedTasks =
                 TaskPrioritizer.<VariableDescriptor, VariableDescriptor>computePrioritizedTasks(
                         context, referencedName, tracing, callableDescriptorCollectors);
-        return doResolveCallOrGetCachedResults(ResolutionResultsCache.PROPERTY_MEMBER_TYPE,
-                context, prioritizedTasks, CallTransformer.PROPERTY_CALL_TRANSFORMER, tracing);
+        return doResolveCallOrGetCachedResults(context, prioritizedTasks, CallTransformer.PROPERTY_CALL_TRANSFORMER, tracing);
     }
 
     @NotNull
@@ -156,8 +154,7 @@ public class CallResolver {
     ) {
         List<ResolutionTask<CallableDescriptor, FunctionDescriptor>> tasks =
                 TaskPrioritizer.<CallableDescriptor, FunctionDescriptor>computePrioritizedTasks(context, name, tracing, collectors);
-        return doResolveCallOrGetCachedResults(ResolutionResultsCache.FUNCTION_MEMBER_TYPE,
-                                               context, tasks, CallTransformer.FUNCTION_CALL_TRANSFORMER, tracing);
+        return doResolveCallOrGetCachedResults(context, tasks, CallTransformer.FUNCTION_CALL_TRANSFORMER, tracing);
     }
 
     @NotNull
@@ -300,8 +297,7 @@ public class CallResolver {
 
         TracingStrategy tracing = TracingStrategyImpl.create(functionReference, context.call);
         OverloadResolutionResultsImpl<FunctionDescriptor> results = doResolveCallOrGetCachedResults(
-                ResolutionResultsCache.FUNCTION_MEMBER_TYPE, context, prioritizedTasks,
-                CallTransformer.FUNCTION_CALL_TRANSFORMER, tracing);
+                context, prioritizedTasks, CallTransformer.FUNCTION_CALL_TRANSFORMER, tracing);
         if (calleeExpression instanceof JetSimpleNameExpression) {
             ExpressionTypingUtils.checkCapturingInClosure((JetSimpleNameExpression) calleeExpression, context.trace, context.scope);
         }
@@ -321,12 +317,11 @@ public class CallResolver {
         List<ResolutionTask<CallableDescriptor, FunctionDescriptor>> tasks =
                 TaskPrioritizer.<CallableDescriptor, FunctionDescriptor>computePrioritizedTasksFromCandidates(
                         basicCallResolutionContext, Collections.singleton(candidate), tracing);
-        return doResolveCallOrGetCachedResults(ResolutionResultsCache.FUNCTION_MEMBER_TYPE, basicCallResolutionContext, tasks,
-                                               CallTransformer.FUNCTION_CALL_TRANSFORMER, tracing);
+        return doResolveCallOrGetCachedResults(
+                basicCallResolutionContext, tasks, CallTransformer.FUNCTION_CALL_TRANSFORMER, tracing);
     }
 
     private <D extends CallableDescriptor, F extends D> OverloadResolutionResultsImpl<F> doResolveCallOrGetCachedResults(
-            @NotNull ResolutionResultsCache.MemberType<F> memberType,
             @NotNull BasicCallResolutionContext context,
             @NotNull List<ResolutionTask<D, F>> prioritizedTasks,
             @NotNull CallTransformer<D, F> callTransformer,
@@ -336,7 +331,7 @@ public class CallResolver {
         TemporaryBindingTrace traceToResolveCall = TemporaryBindingTrace.create(context.trace, "trace to resolve call", context.call);
         CallKey callKey = CallResolverUtil.createCallKey(context);
         if (callKey != null) {
-            OverloadResolutionResultsImpl<F> cachedResults = context.resolutionResultsCache.getResolutionResults(callKey, memberType);
+            OverloadResolutionResultsImpl<F> cachedResults = context.resolutionResultsCache.getResolutionResults(callKey);
             if (cachedResults != null) {
                 DelegatingBindingTrace deltasTraceForResolve = context.resolutionResultsCache.getResolutionTrace(callKey);
                 assert deltasTraceForResolve != null;
@@ -352,7 +347,7 @@ public class CallResolver {
                 deltasTraceForTypeInference.addAllMyDataTo(traceToResolveCall);
             }
             completeTypeInferenceDependentOnFunctionLiterals(newContext, results, tracing);
-            cacheResults(memberType, context, results, traceToResolveCall, tracing);
+            cacheResults(context, results, traceToResolveCall, tracing);
         }
         traceToResolveCall.commit();
 
@@ -417,7 +412,6 @@ public class CallResolver {
     }
 
     private static <F extends CallableDescriptor> void cacheResults(
-            @NotNull ResolutionResultsCache.MemberType<F> memberType,
             @NotNull BasicCallResolutionContext context,
             @NotNull OverloadResolutionResultsImpl<F> results,
             @NotNull DelegatingBindingTrace traceToResolveCall,
@@ -430,7 +424,7 @@ public class CallResolver {
                 BindingContext.EMPTY, "delta trace for caching resolve of", context.call);
         traceToResolveCall.addAllMyDataTo(deltasTraceToCacheResolve);
 
-        context.resolutionResultsCache.recordResolutionResults(callKey, memberType, results);
+        context.resolutionResultsCache.recordResolutionResults(callKey, results);
         context.resolutionResultsCache.recordResolutionTrace(callKey, deltasTraceToCacheResolve);
 
         if (results.isSingleResult()) {
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/ResolutionResultsCache.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/ResolutionResultsCache.java
index 4246f294f20..688e5e39a2c 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/ResolutionResultsCache.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/ResolutionResultsCache.java
@@ -19,8 +19,6 @@ package org.jetbrains.jet.lang.resolve.calls.context;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
-import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
-import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
 import org.jetbrains.jet.lang.psi.CallKey;
 import org.jetbrains.jet.lang.psi.JetExpression;
 import org.jetbrains.jet.lang.resolve.DelegatingBindingTrace;
@@ -28,26 +26,11 @@ import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCallWithTrace;
 import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResultsImpl;
 
 public interface ResolutionResultsCache {
-    class MemberType<D extends CallableDescriptor> {
-        public final String debugName;
 
-        public MemberType(String name) {
-            debugName = name;
-        }
-
-        @Override
-        public String toString() {
-            return debugName;
-        }
-    }
-    MemberType<FunctionDescriptor> FUNCTION_MEMBER_TYPE = new MemberType<FunctionDescriptor>("FUNCTION_MEMBER_TYPE");
-    MemberType<VariableDescriptor> PROPERTY_MEMBER_TYPE = new MemberType<VariableDescriptor>("PROPERTY_MEMBER_TYPE");
-
-
-    <D extends CallableDescriptor> void recordResolutionResults(@NotNull CallKey callKey, @NotNull MemberType<D> memberType, @NotNull OverloadResolutionResultsImpl<D> results);
+    <D extends CallableDescriptor> void recordResolutionResults(@NotNull CallKey callKey, @NotNull OverloadResolutionResultsImpl<D> results);
 
     @Nullable
-    <D extends CallableDescriptor> OverloadResolutionResultsImpl<D> getResolutionResults(@NotNull CallKey callKey, @NotNull MemberType<D> memberType);
+    <D extends CallableDescriptor> OverloadResolutionResultsImpl<D> getResolutionResults(@NotNull CallKey callKey);
 
     void recordResolutionTrace(@NotNull CallKey callKey, @NotNull DelegatingBindingTrace delegatingTrace);
 
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/ResolutionResultsCacheImpl.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/ResolutionResultsCacheImpl.java
index ef0f891b0cb..33c213bd89a 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/ResolutionResultsCacheImpl.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/ResolutionResultsCacheImpl.java
@@ -20,8 +20,6 @@ import com.google.common.collect.Lists;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
-import org.jetbrains.jet.lang.descriptors.FunctionDescriptor;
-import org.jetbrains.jet.lang.descriptors.VariableDescriptor;
 import org.jetbrains.jet.lang.psi.CallKey;
 import org.jetbrains.jet.lang.psi.JetExpression;
 import org.jetbrains.jet.lang.resolve.BindingContext;
@@ -36,8 +34,7 @@ import static org.jetbrains.jet.lang.psi.Call.CallType;
 import static org.jetbrains.jet.lang.psi.Call.CallType.*;
 
 public class ResolutionResultsCacheImpl implements ResolutionResultsCache {
-    public static final WritableSlice<CallKey, OverloadResolutionResultsImpl<FunctionDescriptor>> RESOLUTION_RESULTS_FOR_FUNCTION = Slices.createSimpleSlice();
-    public static final WritableSlice<CallKey, OverloadResolutionResultsImpl<VariableDescriptor>> RESOLUTION_RESULTS_FOR_PROPERTY = Slices.createSimpleSlice();
+    public static final WritableSlice<CallKey, OverloadResolutionResultsImpl<CallableDescriptor>> RESOLUTION_RESULTS = Slices.createSimpleSlice();
     public static final WritableSlice<CallKey, DelegatingBindingTrace> TRACE_DELTAS_CACHE = Slices.createSimpleSlice();
     public static final WritableSlice<CallKey, CallCandidateResolutionContext<?>> DEFERRED_COMPUTATION_FOR_CALL = Slices.createSimpleSlice();
     public static final WritableSlice<CallKey, ResolvedCallWithTrace<?>> RESOLVED_CALL_FOR_ARGUMENT = Slices.createSimpleSlice();
@@ -49,22 +46,22 @@ public class ResolutionResultsCacheImpl implements ResolutionResultsCache {
     private final DelegatingBindingTrace trace = new DelegatingBindingTrace(
             BindingContext.EMPTY, "Internal binding context in resolution results cache");
 
-    @NotNull
-    private static <D extends CallableDescriptor> WritableSlice<CallKey, OverloadResolutionResultsImpl<D>> getSliceByMemberType(@NotNull MemberType<D> memberType) {
-        //noinspection unchecked
-        return (WritableSlice<CallKey, OverloadResolutionResultsImpl<D>>)
-                (memberType == FUNCTION_MEMBER_TYPE ? RESOLUTION_RESULTS_FOR_FUNCTION : RESOLUTION_RESULTS_FOR_PROPERTY);
-    }
-
     @Override
-    public <D extends CallableDescriptor> void recordResolutionResults(@NotNull CallKey callKey, @NotNull MemberType<D> memberType, @NotNull OverloadResolutionResultsImpl<D> results) {
-        trace.record(getSliceByMemberType(memberType), callKey, results);
+    public <D extends CallableDescriptor> void recordResolutionResults(
+            @NotNull CallKey callKey,
+            @NotNull OverloadResolutionResultsImpl<D> results
+    ) {
+        //noinspection unchecked
+        trace.record(RESOLUTION_RESULTS, callKey, (OverloadResolutionResultsImpl<CallableDescriptor>) results);
     }
 
     @Override
     @Nullable
-    public <D extends CallableDescriptor> OverloadResolutionResultsImpl<D> getResolutionResults(@NotNull CallKey callKey, @NotNull MemberType<D> memberType) {
-        return trace.get(getSliceByMemberType(memberType), callKey);
+    public <D extends CallableDescriptor> OverloadResolutionResultsImpl<D> getResolutionResults(
+            @NotNull CallKey callKey
+    ) {
+        //noinspection unchecked
+        return (OverloadResolutionResultsImpl<D>) trace.get(RESOLUTION_RESULTS, callKey);
     }
 
     @Override
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/TemporaryResolutionResultsCache.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/TemporaryResolutionResultsCache.java
index 76384000d2c..c4593f9a653 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/TemporaryResolutionResultsCache.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/context/TemporaryResolutionResultsCache.java
@@ -39,22 +39,21 @@ public class TemporaryResolutionResultsCache implements ResolutionResultsCache {
     @Override
     public <D extends CallableDescriptor> void recordResolutionResults(
             @NotNull CallKey callKey,
-            @NotNull MemberType<D> memberType,
             @NotNull OverloadResolutionResultsImpl<D> results
     ) {
-        innerCache.recordResolutionResults(callKey, memberType, results);
+        innerCache.recordResolutionResults(callKey, results);
     }
 
     @Nullable
     @Override
     public <D extends CallableDescriptor> OverloadResolutionResultsImpl<D> getResolutionResults(
-            @NotNull CallKey callKey, @NotNull MemberType<D> memberType
+            @NotNull CallKey callKey
     ) {
-        OverloadResolutionResultsImpl<D> results = innerCache.getResolutionResults(callKey, memberType);
+        OverloadResolutionResultsImpl<D> results = innerCache.getResolutionResults(callKey);
         if (results != null) {
             return results;
         }
-        return parentCache.getResolutionResults(callKey, memberType);
+        return parentCache.getResolutionResults(callKey);
     }
 
     @Override