diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java
index 655c9ca3a4f..5a14b835dad 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingContext.java
@@ -1,6 +1,7 @@
 package org.jetbrains.jet.lang.resolve;
 
 import com.intellij.psi.PsiElement;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
@@ -12,7 +13,7 @@ import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.types.DeferredType;
 import org.jetbrains.jet.lang.types.JetType;
-import org.jetbrains.jet.util.CommonSuppliers;
+import org.jetbrains.jet.util.Box;
 import org.jetbrains.jet.util.slicedmap.*;
 
 import java.util.Collection;
@@ -51,10 +52,10 @@ public interface BindingContext {
 
     WritableSlice<VariableDescriptor, Boolean> MUST_BE_WRAPPED_IN_A_REF = Slices.createSimpleSetSlice();
     
-    enum DeferredTypeKey {DEFERRED_TYPE_KEY}
-    WritableSlice<DeferredTypeKey, Collection<DeferredType>> DEFERRED_TYPES = Slices.createSimpleSlice();
-    
-    WritableSlice<DeferredTypeKey, DeferredType> DEFERRED_TYPE = new CollectionSliceWrapper<DeferredTypeKey, DeferredType>(DEFERRED_TYPES, CommonSuppliers.<DeferredType>getArrayListSupplier());
+//    enum DeferredTypeKey {DEFERRED_TYPE_KEY}
+//    WritableSlice<DeferredTypeKey, Collection<DeferredType>> DEFERRED_TYPES = Slices.createSimpleSlice();
+
+    WritableSlice<Box<DeferredType>, Boolean> DEFERRED_TYPE = Slices.createCollectiveSetSlice();
 
     WritableSlice<PropertyDescriptor, Boolean> BACKING_FIELD_REQUIRED = new Slices.SetSlice<PropertyDescriptor>(RewritePolicy.DO_NOTHING) {
         @Override
@@ -139,4 +140,8 @@ public interface BindingContext {
 
     @Nullable
     <K, V> V get(ReadOnlySlice<K, V> slice, K key);
+
+    // slice.isCollective() must be true
+    @NotNull
+    <K, V> Collection<K> getKeys(WritableSlice<K, V> slice);
 }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingTrace.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingTrace.java
index b346cf32938..4e876d2f52c 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingTrace.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingTrace.java
@@ -1,10 +1,13 @@
 package org.jetbrains.jet.lang.resolve;
 
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.lang.diagnostics.DiagnosticHolder;
 import org.jetbrains.jet.util.slicedmap.ReadOnlySlice;
 import org.jetbrains.jet.util.slicedmap.WritableSlice;
 
+import java.util.Collection;
+
 /**
  * @author abreslav
  */
@@ -19,4 +22,8 @@ public interface BindingTrace extends DiagnosticHolder {
 
     @Nullable
     <K, V> V get(ReadOnlySlice<K, V> slice, K key);
+
+    // slice.isCollective() must be true
+    @NotNull
+    <K, V> Collection<K> getKeys(WritableSlice<K, V> slice);
 }
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingTraceContext.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingTraceContext.java
index 1ada727f830..323bd4f5308 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingTraceContext.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BindingTraceContext.java
@@ -30,6 +30,12 @@ public class BindingTraceContext implements BindingTrace {
         public <K, V> V get(ReadOnlySlice<K, V> slice, K key) {
             return BindingTraceContext.this.get(slice, key);
         }
+
+        @NotNull
+        @Override
+        public <K, V> Collection<K> getKeys(WritableSlice<K, V> slice) {
+            return BindingTraceContext.this.getKeys(slice);
+        }
     };
 
     @Override
@@ -56,4 +62,10 @@ public class BindingTraceContext implements BindingTrace {
     public <K, V> V get(ReadOnlySlice<K, V> slice, K key) {
         return map.get(slice, key);
     }
+
+    @NotNull
+    @Override
+    public <K, V> Collection<K> getKeys(WritableSlice<K, V> slice) {
+        return map.getKeys(slice);
+    }
 }
\ No newline at end of file
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java
index 0048d2e6439..ef5e309947f 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/BodyResolver.java
@@ -18,6 +18,7 @@ import org.jetbrains.jet.lang.resolve.scopes.receivers.ReceiverDescriptor;
 import org.jetbrains.jet.lang.types.*;
 import org.jetbrains.jet.lang.types.expressions.ExpressionTypingServices;
 import org.jetbrains.jet.lexer.JetTokens;
+import org.jetbrains.jet.util.Box;
 import org.jetbrains.jet.util.lazy.ReenteringLazyValueComputationException;
 import org.jetbrains.jet.util.slicedmap.WritableSlice;
 
@@ -25,8 +26,6 @@ import java.util.*;
 
 import static org.jetbrains.jet.lang.diagnostics.Errors.*;
 import static org.jetbrains.jet.lang.resolve.BindingContext.DEFERRED_TYPE;
-import static org.jetbrains.jet.lang.resolve.BindingContext.DEFERRED_TYPES;
-import static org.jetbrains.jet.lang.resolve.BindingContext.DeferredTypeKey.DEFERRED_TYPE_KEY;
 import static org.jetbrains.jet.lang.types.TypeUtils.NO_EXPECTED_TYPE;
 
 /**
@@ -544,17 +543,17 @@ public class BodyResolver {
     }
 
     private void computeDeferredTypes() {
-        Collection<DeferredType> deferredTypes = context.getTrace().get(DEFERRED_TYPES, DEFERRED_TYPE_KEY);
+        Collection<Box<DeferredType>> deferredTypes = context.getTrace().getKeys(DEFERRED_TYPE);
         if (deferredTypes != null) {
             final Queue<DeferredType> queue = new Queue<DeferredType>(deferredTypes.size());
-            context.getTrace().addHandler(DEFERRED_TYPE, new ObservableBindingTrace.RecordHandler<BindingContext.DeferredTypeKey, DeferredType>() {
+            context.getTrace().addHandler(DEFERRED_TYPE, new ObservableBindingTrace.RecordHandler<Box<DeferredType>, Boolean>() {
                 @Override
-                public void handleRecord(WritableSlice<BindingContext.DeferredTypeKey, DeferredType> deferredTypeKeyDeferredTypeWritableSlice, BindingContext.DeferredTypeKey key, DeferredType value) {
-                    queue.addLast(value);
+                public void handleRecord(WritableSlice<Box<DeferredType>, Boolean> deferredTypeKeyDeferredTypeWritableSlice, Box<DeferredType> key, Boolean value) {
+                    queue.addLast(key.getData());
                 }
             });
-            for (DeferredType deferredType : deferredTypes) {
-                queue.addLast(deferredType);
+            for (Box<DeferredType> deferredType : deferredTypes) {
+                queue.addLast(deferredType.getData());
             }
             while (!queue.isEmpty()) {
                 DeferredType deferredType = queue.pullFirst();
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegatingBindingTrace.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegatingBindingTrace.java
index 416a0b54e5d..8c18b558dc8 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegatingBindingTrace.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/DelegatingBindingTrace.java
@@ -27,6 +27,13 @@ public class DelegatingBindingTrace implements BindingTrace {
         public <K, V> V get(ReadOnlySlice<K, V> slice, K key) {
             return DelegatingBindingTrace.this.get(slice, key);
         }
+
+        @NotNull
+        @Override
+        public <K, V> Collection<K> getKeys(WritableSlice<K, V> slice) {
+            return DelegatingBindingTrace.this.getKeys(slice);
+
+        }
     };
 
     public DelegatingBindingTrace(BindingContext parentContext) {
@@ -56,6 +63,19 @@ public class DelegatingBindingTrace implements BindingTrace {
         return parentContext.get(slice, key);
     }
 
+    @NotNull
+    @Override
+    public <K, V> Collection<K> getKeys(WritableSlice<K, V> slice) {
+        Collection<K> keys = map.getKeys(slice);
+        Collection<K> fromParent = parentContext.getKeys(slice);
+        if (keys.isEmpty()) return fromParent;
+        if (fromParent.isEmpty()) return keys;
+
+        List<K> result = Lists.newArrayList(keys);
+        result.addAll(fromParent);
+        return result;
+    }
+
     public void addAllMyDataTo(BindingTrace trace) {
         for (Map.Entry<SlicedMapKey<?, ?>, ?> entry : map) {
             SlicedMapKey slicedMapKey = entry.getKey();
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ObservableBindingTrace.java b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ObservableBindingTrace.java
index 928c463217b..9a5e4753233 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ObservableBindingTrace.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/resolve/ObservableBindingTrace.java
@@ -6,6 +6,7 @@ import org.jetbrains.jet.lang.diagnostics.Diagnostic;
 import org.jetbrains.jet.util.slicedmap.ReadOnlySlice;
 import org.jetbrains.jet.util.slicedmap.WritableSlice;
 
+import java.util.Collection;
 import java.util.Map;
 
 /**
@@ -16,13 +17,14 @@ public class ObservableBindingTrace implements BindingTrace {
 
         void handleRecord(WritableSlice<K, V> slice, K key, V value);
     }
+
     private final BindingTrace originalTrace;
 
     private Map<WritableSlice, RecordHandler> handlers = Maps.newHashMap();
+
     public ObservableBindingTrace(BindingTrace originalTrace) {
         this.originalTrace = originalTrace;
     }
-
     @Override
     public void report(@NotNull Diagnostic diagnostic) {
         originalTrace.report(diagnostic);
@@ -51,7 +53,13 @@ public class ObservableBindingTrace implements BindingTrace {
     public <K, V> V get(ReadOnlySlice<K, V> slice, K key) {
         return originalTrace.get(slice, key);
     }
-    
+
+    @Override
+    @NotNull
+    public <K, V> Collection<K> getKeys(WritableSlice<K, V> slice) {
+        return originalTrace.getKeys(slice);
+    }
+
     public <K, V> ObservableBindingTrace addHandler(@NotNull WritableSlice<K, V> slice, @NotNull RecordHandler<K, V> handler) {
         handlers.put(slice, handler);
         return this;
diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/types/DeferredType.java b/compiler/frontend/src/org/jetbrains/jet/lang/types/DeferredType.java
index b30846b1441..dbc0de18316 100644
--- a/compiler/frontend/src/org/jetbrains/jet/lang/types/DeferredType.java
+++ b/compiler/frontend/src/org/jetbrains/jet/lang/types/DeferredType.java
@@ -4,13 +4,13 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.resolve.BindingTrace;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
+import org.jetbrains.jet.util.Box;
 import org.jetbrains.jet.util.lazy.LazyValue;
 import org.jetbrains.jet.util.lazy.ReenteringLazyValueComputationException;
 
 import java.util.List;
 
 import static org.jetbrains.jet.lang.resolve.BindingContext.DEFERRED_TYPE;
-import static org.jetbrains.jet.lang.resolve.BindingContext.DeferredTypeKey.DEFERRED_TYPE_KEY;
 
 /**
  * @author abreslav
@@ -19,7 +19,7 @@ public class DeferredType implements JetType {
     
     public static DeferredType create(BindingTrace trace, LazyValue<JetType> lazyValue) {
         DeferredType deferredType = new DeferredType(lazyValue);
-        trace.record(DEFERRED_TYPE, DEFERRED_TYPE_KEY, deferredType);
+        trace.record(DEFERRED_TYPE, new Box<DeferredType>(deferredType));
         return deferredType;
     }
     
diff --git a/compiler/frontend/src/org/jetbrains/jet/util/Box.java b/compiler/frontend/src/org/jetbrains/jet/util/Box.java
new file mode 100644
index 00000000000..f89337c6f51
--- /dev/null
+++ b/compiler/frontend/src/org/jetbrains/jet/util/Box.java
@@ -0,0 +1,26 @@
+package org.jetbrains.jet.util;
+
+/**
+* @author abreslav
+*/
+public class Box<T> {
+    private final T data;
+
+    public Box(T data) {
+        this.data = data;
+    }
+
+    public T getData() {
+        return data;
+    }
+
+    @Override
+    public int hashCode() {
+        return super.hashCode(); // This class is needed to screen from calling data's hashCode()
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        return super.equals(obj); // This class is needed to screen from calling data's equals()
+    }
+}
diff --git a/compiler/frontend/src/org/jetbrains/jet/util/CommonSuppliers.java b/compiler/frontend/src/org/jetbrains/jet/util/CommonSuppliers.java
index d467debb201..e4102d25a51 100644
--- a/compiler/frontend/src/org/jetbrains/jet/util/CommonSuppliers.java
+++ b/compiler/frontend/src/org/jetbrains/jet/util/CommonSuppliers.java
@@ -27,6 +27,13 @@ public class CommonSuppliers {
         }
     };
 
+    private static final Supplier<?> HASH_SET_SUPPLIER = new Supplier() {
+        @Override
+        public Set get() {
+            return Sets.newHashSet();
+        }
+    };
+
     public static <T> Supplier<List<T>> getArrayListSupplier() {
         //noinspection unchecked
         return (Supplier<List<T>>) ARRAY_LIST_SUPPLIER;
@@ -36,7 +43,12 @@ public class CommonSuppliers {
         //noinspection unchecked
         return (Supplier<Set<T>>) LINKED_HASH_SET_SUPPLIER;
     }
-    
+
+    public static <T> Supplier<Set<T>> getHashSetSupplier() {
+        //noinspection unchecked
+        return (Supplier<Set<T>>) HASH_SET_SUPPLIER;
+    }
+
     public static <K, V> SetMultimap<K, V> newLinkedHashSetHashSetMultimap() {
         return Multimaps.newSetMultimap(Maps.<K, Collection<V>>newHashMap(), CommonSuppliers.<V>getLinkedHashSetSupplier());
     }
diff --git a/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/BasicWritableSlice.java b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/BasicWritableSlice.java
index 4afb0dded7e..8ff50070242 100644
--- a/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/BasicWritableSlice.java
+++ b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/BasicWritableSlice.java
@@ -39,8 +39,8 @@ public class BasicWritableSlice<K, V> implements WritableSlice<K,V> {
     // True to put, false to skip
     @Override
     public boolean check(K key, V value) {
-        assert key != null;
-        assert value != null;
+//        assert key != null : this + " called with null key";
+        assert value != null : this + " called with null value";
         return true;
     }
 
@@ -60,6 +60,10 @@ public class BasicWritableSlice<K, V> implements WritableSlice<K,V> {
         return rewritePolicy;
     }
 
+    @Override
+    public boolean isCollective() {
+        return false;
+    }
 
     @Override
     public String toString() {
diff --git a/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/CollectionSliceWrapper.java b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/CollectionSliceWrapper.java
deleted file mode 100644
index faded385ac3..00000000000
--- a/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/CollectionSliceWrapper.java
+++ /dev/null
@@ -1,57 +0,0 @@
-package org.jetbrains.jet.util.slicedmap;
-
-import com.google.common.base.Supplier;
-
-import java.util.Collection;
-
-/**
- * @author abreslav
- */
-public class CollectionSliceWrapper<K, V> implements WritableSlice<K, V> {
-    
-    private final WritableSlice<K, Collection<V>> wrapped;
-    private final SlicedMapKey<K, V> myKey;
-    private final Supplier<? extends Collection<V>> supplier;
-
-    public CollectionSliceWrapper(WritableSlice<K, Collection<V>> wrapped, Supplier<? extends Collection<V>> supplier) {
-        this.wrapped = wrapped;
-        this.supplier = supplier;
-        this.myKey = new SlicedMapKey<K, V>(this, null);
-    }
-
-    @Override
-    public SlicedMapKey<K, V> makeKey(K key) {
-        return myKey;
-    }
-
-    @Override
-    public boolean check(K key, V value) {
-        assert value != null;
-        return true;
-    }
-
-    @Override
-    public void afterPut(MutableSlicedMap map, K key, V value) {
-        Collection<V> collection = map.get(wrapped, key);
-        if (collection == null) {
-            collection = supplier.get();
-            map.put(wrapped, key, collection);
-        }
-        collection.add(value);
-    }
-
-    @Override
-    public RewritePolicy getRewritePolicy() {
-        return RewritePolicy.DO_NOTHING;
-    }
-
-    @Override
-    public V computeValue(SlicedMap map, K key, V value, boolean valueNotFound) {
-        throw new UnsupportedOperationException("Don't read by this slice, use the wrapped one");
-    }
-
-    @Override
-    public ReadOnlySlice<K, V> makeRawValueVersion() {
-        return this;
-    }
-}
\ No newline at end of file
diff --git a/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/DelegatingSlice.java b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/DelegatingSlice.java
index cf415533340..8c3c6d641cd 100644
--- a/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/DelegatingSlice.java
+++ b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/DelegatingSlice.java
@@ -12,6 +12,11 @@ public class DelegatingSlice<K, V> implements WritableSlice<K, V> {
         this.delegate = delegate;
     }
 
+    @Override
+    public boolean isCollective() {
+        return delegate.isCollective();
+    }
+
     public boolean check(K key, V value) {
         return delegate.check(key, value);
     }
diff --git a/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/SlicedMap.java b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/SlicedMap.java
index 7626cb2ddbc..79e26176135 100644
--- a/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/SlicedMap.java
+++ b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/SlicedMap.java
@@ -1,5 +1,6 @@
 package org.jetbrains.jet.util.slicedmap;
 
+import java.util.Collection;
 import java.util.Map;
 
 /**
@@ -9,6 +10,7 @@ public interface SlicedMap extends Iterable<Map.Entry<SlicedMapKey<?, ?>, ?>> {
     <K, V> V get(ReadOnlySlice<K, V> slice, K key);
 
     <K, V> boolean containsKey(ReadOnlySlice<K, V> slice, K key);
-    
-    
+
+    // slice.isCollective() must return true
+    <K, V> Collection<K> getKeys(WritableSlice<K, V> slice);
 }
diff --git a/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/SlicedMapImpl.java b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/SlicedMapImpl.java
index 70182bb6ee4..3a67a8e663d 100644
--- a/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/SlicedMapImpl.java
+++ b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/SlicedMapImpl.java
@@ -1,7 +1,12 @@
 package org.jetbrains.jet.util.slicedmap;
 
 import com.google.common.collect.Maps;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.Multimaps;
+import org.jetbrains.jet.util.CommonSuppliers;
 
+import java.util.Collection;
+import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;
 
@@ -23,6 +28,7 @@ public class SlicedMapImpl implements MutableSlicedMap {
     }
     
     private final Map<SlicedMapKey<?, ?>, Object> map;
+    private final Multimap<WritableSlice<?, ?>, Object> collectiveSliceKeys = Multimaps.newListMultimap(new HashMap<WritableSlice<?, ?>, Collection<Object>>(), CommonSuppliers.getArrayListSupplier());
 
     private SlicedMapImpl(Map<SlicedMapKey<?, ?>, Object> map) {
         this.map = map;
@@ -33,6 +39,7 @@ public class SlicedMapImpl implements MutableSlicedMap {
         if (!slice.check(key, value)) {
             return;
         }
+
         SlicedMapKey<K, V> slicedMapKey = slice.makeKey(key);
         RewritePolicy rewritePolicy = slice.getRewritePolicy();
         if (rewritePolicy.rewriteProcessingNeeded(key)) {
@@ -43,6 +50,11 @@ public class SlicedMapImpl implements MutableSlicedMap {
                 }
             }
         }
+
+        if (slice.isCollective()) {
+            collectiveSliceKeys.put(slice, key);
+        }
+
         map.put(slicedMapKey, value);
         slice.afterPut(this, key, value);
     }
@@ -60,6 +72,13 @@ public class SlicedMapImpl implements MutableSlicedMap {
         return slice.computeValue(this, key, value, value == null && !map.containsKey(slicedMapKey));
     }
 
+    @Override
+    @SuppressWarnings("unchecked")
+    public <K, V> Collection<K> getKeys(WritableSlice<K, V> slice) {
+        assert slice.isCollective() : "Keys are not collected for slice " + slice;
+        return (Collection<K>) collectiveSliceKeys.get(slice);
+    }
+
     @Override
     public <K, V> boolean containsKey(ReadOnlySlice<K, V> slice, K key) {
         return map.containsKey(slice.makeKey(key));
diff --git a/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/Slices.java b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/Slices.java
index 546c2fd4f45..cd206d72bab 100644
--- a/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/Slices.java
+++ b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/Slices.java
@@ -17,7 +17,10 @@ public class Slices {
         @Override
         public <K, V> boolean processRewrite(WritableSlice<K, V> slice, K key, V oldValue, V newValue) {
             assert (oldValue == null && newValue == null) || (oldValue != null && oldValue.equals(newValue))
-                    : "Rewrite at slice " + slice + " key: " + key + " old value: " + oldValue + " new value: " + newValue;
+                    : "Rewrite at slice " + slice +
+                      " key: " + key +
+                      " old value: " + oldValue + '@' + System.identityHashCode(oldValue) +
+                      " new value: " + newValue + '@' + System.identityHashCode(newValue);
             return true;
         }
     };
@@ -45,8 +48,13 @@ public class Slices {
     public static <K> WritableSlice<K, Boolean> createSimpleSetSlice() {
         return createRemovableSetSlice();
     }
+
+    public static <K> WritableSlice<K, Boolean> createCollectiveSetSlice() {
+        return new SetSlice<K>(RewritePolicy.DO_NOTHING, true);
+    }
+
     public static <K> RemovableSlice<K, Boolean> createRemovableSetSlice() {
-        return new SetSlice<K>(RewritePolicy.DO_NOTHING);
+        return new SetSlice<K>(RewritePolicy.DO_NOTHING, false);
     }
 
     public static class SliceBuilder<K, V> {
@@ -157,8 +165,15 @@ public class Slices {
 
     public static class SetSlice<K> extends BasicRemovableSlice<K, Boolean> {
 
+        private final boolean collective;
+
         protected SetSlice(RewritePolicy rewritePolicy) {
+            this(rewritePolicy, false);
+        }
+
+        protected SetSlice(RewritePolicy rewritePolicy, boolean collective) {
             super(rewritePolicy);
+            this.collective = collective;
         }
 
         @Override
@@ -167,6 +182,10 @@ public class Slices {
             return super.computeValue(map, key, value, valueNotFound);
         }
 
+        @Override
+        public boolean isCollective() {
+            return collective;
+        }
     }
 
 }
diff --git a/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/WritableSlice.java b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/WritableSlice.java
index df173532564..10afe54a44e 100644
--- a/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/WritableSlice.java
+++ b/compiler/frontend/src/org/jetbrains/jet/util/slicedmap/WritableSlice.java
@@ -10,4 +10,7 @@ public interface WritableSlice<K, V> extends ReadOnlySlice<K, V> {
     void afterPut(MutableSlicedMap map, K key, V value);
 
     RewritePolicy getRewritePolicy();
+
+    // In a sliced map one can request all keys for a collective slice
+    boolean isCollective();
 }
diff --git a/compiler/testData/checkerWithErrorTypes/full/regression/ErrorsOnIbjectExpressionsAsParameters.jet b/compiler/testData/checkerWithErrorTypes/full/regression/ErrorsOnIbjectExpressionsAsParameters.jet
new file mode 100644
index 00000000000..75432316689
--- /dev/null
+++ b/compiler/testData/checkerWithErrorTypes/full/regression/ErrorsOnIbjectExpressionsAsParameters.jet
@@ -0,0 +1,5 @@
+fun foo(a : Any) {}
+
+fun test() {
+  foo(object {});
+}
\ No newline at end of file
diff --git a/compiler/tests/org/jetbrains/jet/JetTestUtils.java b/compiler/tests/org/jetbrains/jet/JetTestUtils.java
index 9cb42a1648e..26e29d8b777 100644
--- a/compiler/tests/org/jetbrains/jet/JetTestUtils.java
+++ b/compiler/tests/org/jetbrains/jet/JetTestUtils.java
@@ -10,6 +10,7 @@ import org.jetbrains.jet.util.slicedmap.ReadOnlySlice;
 import org.jetbrains.jet.util.slicedmap.WritableSlice;
 
 import java.util.Collection;
+import java.util.Collections;
 
 /**
  * @author abreslav
@@ -31,6 +32,12 @@ public class JetTestUtils {
                 public <K, V> V get(ReadOnlySlice<K, V> slice, K key) {
                     return DUMMY_TRACE.get(slice, key);
                 }
+
+                @NotNull
+                @Override
+                public <K, V> Collection<K> getKeys(WritableSlice<K, V> slice) {
+                    return DUMMY_TRACE.getKeys(slice);
+                }
             };
         }
 
@@ -48,6 +55,13 @@ public class JetTestUtils {
             return null;
         }
 
+        @NotNull
+        @Override
+        public <K, V> Collection<K> getKeys(WritableSlice<K, V> slice) {
+            assert slice.isCollective();
+            return Collections.emptySet();
+        }
+
         @Override
         public void report(@NotNull Diagnostic diagnostic) {
             if (diagnostic instanceof UnresolvedReferenceDiagnostic) {
@@ -70,6 +84,12 @@ public class JetTestUtils {
                     public <K, V> V get(ReadOnlySlice<K, V> slice, K key) {
                         return DUMMY_EXCEPTION_ON_ERROR_TRACE.get(slice, key);
                     }
+
+                    @NotNull
+                    @Override
+                    public <K, V> Collection<K> getKeys(WritableSlice<K, V> slice) {
+                        return DUMMY_EXCEPTION_ON_ERROR_TRACE.getKeys(slice);
+                    }
                 };
             }
 
@@ -86,11 +106,18 @@ public class JetTestUtils {
                 return null;
             }
 
+            @NotNull
             @Override
-            public void report(@NotNull Diagnostic diagnostic) {
-                if (diagnostic.getSeverity() == Severity.ERROR) {
-                    throw new IllegalStateException(diagnostic.getMessage());
-                }
+            public <K, V> Collection<K> getKeys(WritableSlice<K, V> slice) {
+                assert slice.isCollective();
+                return Collections.emptySet();
             }
-        };
+
+            @Override
+                public void report(@NotNull Diagnostic diagnostic) {
+                    if (diagnostic.getSeverity() == Severity.ERROR) {
+                        throw new IllegalStateException(diagnostic.getMessage());
+                    }
+                }
+            };
 }