Simplify slices: remove SliceWithOpposite, defaultValue, etc.

compiler/backend/src/org/jetbrains/kotlin/codegen/binding/CodegenBinding.java

@@ -61,11 +61,10 @@ public class CodegenBinding {
 
     public static final WritableSlice<JetCallElement, JetExpression> SAM_CONSTRUCTOR_TO_ARGUMENT = Slices.createSimpleSlice();
 
-    public static final WritableSlice<JetWhenExpression, WhenByEnumsMapping> MAPPING_FOR_WHEN_BY_ENUM =
+    public static final WritableSlice<JetWhenExpression, WhenByEnumsMapping> MAPPING_FOR_WHEN_BY_ENUM = Slices.createSimpleSlice();
-            Slices.<JetWhenExpression, WhenByEnumsMapping>sliceBuilder().build();
 
     public static final WritableSlice<String, List<WhenByEnumsMapping>> MAPPINGS_FOR_WHENS_BY_ENUM_IN_CLASS_FILE =
-            Slices.<String, List<WhenByEnumsMapping>>sliceBuilder().build();
+            Slices.createSimpleSlice();
 
     static {
         BasicWritableSlice.initSliceDebugNames(CodegenBinding.class);

compiler/frontend/src/org/jetbrains/kotlin/resolve/BindingContext.java

@@ -151,8 +151,8 @@ public interface BindingContext {
      * Has type of current expression has been already resolved
      */
     WritableSlice<JetExpression, Boolean> PROCESSED = Slices.createSimpleSetSlice();
-    WritableSlice<JetElement, Boolean> USED_AS_EXPRESSION = Slices.createRemovableSetSlice();
+    WritableSlice<JetElement, Boolean> USED_AS_EXPRESSION = Slices.createSimpleSetSlice();
-    WritableSlice<JetElement, Boolean> UNREACHABLE_CODE = Slices.createRemovableSetSlice();
+    WritableSlice<JetElement, Boolean> UNREACHABLE_CODE = Slices.createSimpleSetSlice();
 
     WritableSlice<VariableDescriptor, CaptureKind> CAPTURED_IN_CLOSURE = new BasicWritableSlice<VariableDescriptor, CaptureKind>(DO_NOTHING);
 
@@ -196,50 +196,45 @@ public interface BindingContext {
         @Override
         public Boolean computeValue(SlicedMap map, JetFunctionLiteralExpression expression, Boolean isBlock, boolean valueNotFound) {
             isBlock = valueNotFound ? false : isBlock;
-            assert isBlock != null;
             return isBlock && !expression.getFunctionLiteral().hasParameterSpecification();
         }
     };
 
-    WritableSlice<PsiElement, ClassDescriptor> CLASS = Slices.<PsiElement, ClassDescriptor>sliceBuilder().build();
+    WritableSlice<PsiElement, ClassDescriptor> CLASS = Slices.createSimpleSlice();
-    WritableSlice<PsiElement, ScriptDescriptor> SCRIPT = Slices.<PsiElement, ScriptDescriptor>sliceBuilder().build();
+    WritableSlice<PsiElement, ScriptDescriptor> SCRIPT = Slices.createSimpleSlice();
-    WritableSlice<JetTypeParameter, TypeParameterDescriptor> TYPE_PARAMETER =
+    WritableSlice<JetTypeParameter, TypeParameterDescriptor> TYPE_PARAMETER = Slices.createSimpleSlice();
-            Slices.<JetTypeParameter, TypeParameterDescriptor>sliceBuilder().build();
     /**
      * @see BindingContextUtils#recordFunctionDeclarationToDescriptor(BindingTrace, PsiElement, SimpleFunctionDescriptor)}
      */
-    WritableSlice<PsiElement, SimpleFunctionDescriptor> FUNCTION = Slices.<PsiElement, SimpleFunctionDescriptor>sliceBuilder().build();
+    WritableSlice<PsiElement, SimpleFunctionDescriptor> FUNCTION = Slices.createSimpleSlice();
-    WritableSlice<PsiElement, ConstructorDescriptor> CONSTRUCTOR = Slices.<PsiElement, ConstructorDescriptor>sliceBuilder().build();
+    WritableSlice<PsiElement, ConstructorDescriptor> CONSTRUCTOR = Slices.createSimpleSlice();
     WritableSlice<ConstructorDescriptor, ResolvedCall<ConstructorDescriptor>> CONSTRUCTOR_RESOLVED_DELEGATION_CALL =
-            Slices.<ConstructorDescriptor, ResolvedCall<ConstructorDescriptor>>sliceBuilder().build();
+            Slices.createSimpleSlice();
-    WritableSlice<PsiElement, VariableDescriptor> VARIABLE = Slices.<PsiElement, VariableDescriptor>sliceBuilder().build();
+    WritableSlice<PsiElement, VariableDescriptor> VARIABLE = Slices.createSimpleSlice();
-    WritableSlice<JetParameter, VariableDescriptor> VALUE_PARAMETER = Slices.<JetParameter, VariableDescriptor>sliceBuilder().build();
+    WritableSlice<JetParameter, VariableDescriptor> VALUE_PARAMETER = Slices.createSimpleSlice();
-    WritableSlice<JetPropertyAccessor, PropertyAccessorDescriptor> PROPERTY_ACCESSOR =
+    WritableSlice<JetPropertyAccessor, PropertyAccessorDescriptor> PROPERTY_ACCESSOR = Slices.createSimpleSlice();
-            Slices.<JetPropertyAccessor, PropertyAccessorDescriptor>sliceBuilder().build();
+    WritableSlice<PsiElement, PropertyDescriptor> PRIMARY_CONSTRUCTOR_PARAMETER = Slices.createSimpleSlice();
-    WritableSlice<PsiElement, PropertyDescriptor> PRIMARY_CONSTRUCTOR_PARAMETER =
-            Slices.<PsiElement, PropertyDescriptor>sliceBuilder().build();
 
     WritableSlice[] DECLARATIONS_TO_DESCRIPTORS = new WritableSlice[] {
             CLASS, TYPE_PARAMETER, FUNCTION, CONSTRUCTOR, VARIABLE, VALUE_PARAMETER, PROPERTY_ACCESSOR,
             PRIMARY_CONSTRUCTOR_PARAMETER
     };
 
-    ReadOnlySlice<PsiElement, DeclarationDescriptor> DECLARATION_TO_DESCRIPTOR = Slices.<PsiElement, DeclarationDescriptor>sliceBuilder()
+    @SuppressWarnings("unchecked")
-            .setFurtherLookupSlices(DECLARATIONS_TO_DESCRIPTORS).build();
+    ReadOnlySlice<PsiElement, DeclarationDescriptor> DECLARATION_TO_DESCRIPTOR =
+            Slices.<PsiElement, DeclarationDescriptor>sliceBuilder()
+                    .setFurtherLookupSlices(DECLARATIONS_TO_DESCRIPTORS)
+                    .build();
 
-    WritableSlice<JetReferenceExpression, PsiElement> LABEL_TARGET = Slices.<JetReferenceExpression, PsiElement>sliceBuilder().build();
+    WritableSlice<JetReferenceExpression, PsiElement> LABEL_TARGET = Slices.createSimpleSlice();
-    @KotlinSignature("val AMBIGUOUS_LABEL_TARGET: WritableSlice<JetReferenceExpression, Collection<PsiElement>>")
+    WritableSlice<JetReferenceExpression, Collection<? extends PsiElement>> AMBIGUOUS_LABEL_TARGET = Slices.createSimpleSlice();
-    WritableSlice<JetReferenceExpression, Collection<? extends PsiElement>> AMBIGUOUS_LABEL_TARGET =
+    WritableSlice<ValueParameterDescriptor, PropertyDescriptor> VALUE_PARAMETER_AS_PROPERTY = Slices.createSimpleSlice();
-            Slices.<JetReferenceExpression, Collection<? extends PsiElement>>sliceBuilder().build();
-    WritableSlice<ValueParameterDescriptor, PropertyDescriptor> VALUE_PARAMETER_AS_PROPERTY =
-            Slices.<ValueParameterDescriptor, PropertyDescriptor>sliceBuilder().build();
 
-    WritableSlice<ValueParameterDescriptor, FunctionDescriptor> DATA_CLASS_COMPONENT_FUNCTION =
+    WritableSlice<ValueParameterDescriptor, FunctionDescriptor> DATA_CLASS_COMPONENT_FUNCTION = Slices.createSimpleSlice();
-            Slices.<ValueParameterDescriptor, FunctionDescriptor>sliceBuilder().build();
+    WritableSlice<ClassDescriptor, FunctionDescriptor> DATA_CLASS_COPY_FUNCTION = Slices.createSimpleSlice();
-    WritableSlice<ClassDescriptor, FunctionDescriptor> DATA_CLASS_COPY_FUNCTION =
-            Slices.<ClassDescriptor, FunctionDescriptor>sliceBuilder().build();
 
-    WritableSlice<FqNameUnsafe, ClassDescriptor> FQNAME_TO_CLASS_DESCRIPTOR = new BasicWritableSlice<FqNameUnsafe, ClassDescriptor>(DO_NOTHING, true);
+    WritableSlice<FqNameUnsafe, ClassDescriptor> FQNAME_TO_CLASS_DESCRIPTOR =
+            new BasicWritableSlice<FqNameUnsafe, ClassDescriptor>(DO_NOTHING, true);
     WritableSlice<JetFile, PackageFragmentDescriptor> FILE_TO_PACKAGE_FRAGMENT = Slices.createSimpleSlice();
     WritableSlice<FqName, Collection<JetFile>> PACKAGE_TO_FILES = Slices.createSimpleSlice();
 

compiler/frontend/src/org/jetbrains/kotlin/util/slicedMap/Slices.java

@@ -60,70 +60,43 @@ public class Slices {
     }
 
     public static <K> WritableSlice<K, Boolean> createSimpleSetSlice() {
-        return createRemovableSetSlice();
+        return new SetSlice<K>(RewritePolicy.DO_NOTHING);
     }
 
     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, false);
-    }
-
     public static class SliceBuilder<K, V> {
-        private V defaultValue = null;
+        private List<ReadOnlySlice<K, V>> furtherLookupSlices;
-        private List<ReadOnlySlice<K, V>> furtherLookupSlices = null;
-        private WritableSlice<? super V, ? super K> opposite = null;
-
         private final RewritePolicy rewritePolicy;
-
         private String debugName;
 
         private SliceBuilder(RewritePolicy rewritePolicy) {
             this.rewritePolicy = rewritePolicy;
         }
 
-        public SliceBuilder<K, V> setDefaultValue(V defaultValue) {
-            this.defaultValue = defaultValue;
-            return this;
-        }
-
         public SliceBuilder<K, V> setFurtherLookupSlices(ReadOnlySlice<K, V>... furtherLookupSlices) {
             this.furtherLookupSlices = Arrays.asList(furtherLookupSlices);
             return this;
         }
 
-        public SliceBuilder<K, V> setOpposite(WritableSlice<? super V, ? super K> opposite) {
-            this.opposite = opposite;
-            return this;
-        }
-
         public SliceBuilder<K, V> setDebugName(@NotNull String debugName) {
             this.debugName = debugName;
             return this;
         }
 
-        public RemovableSlice<K, V>  build() {
+        public RemovableSlice<K, V> build() {
-            SliceWithOpposite<K, V> result = doBuild();
+            BasicRemovableSlice<K, V> result = doBuild();
             if (debugName != null) {
                 result.setDebugName(debugName);
             }
             return result;
         }
 
-        private SliceWithOpposite<K, V> doBuild() {
+        private BasicRemovableSlice<K, V> doBuild() {
-            if (defaultValue != null) {
-                return new SliceWithOpposite<K, V>(rewritePolicy, opposite) {
-                    @Override
-                    public V computeValue(SlicedMap map, K key, V value, boolean valueNotFound) {
-                        if (valueNotFound) return defaultValue;
-                        return super.computeValue(map, key, value, false);
-                    }
-                };
-            }
             if (furtherLookupSlices != null) {
-                return new SliceWithOpposite<K, V>(rewritePolicy, opposite) {
+                return new BasicRemovableSlice<K, V>(rewritePolicy) {
                     @Override
                     public V computeValue(SlicedMap map, K key, V value, boolean valueNotFound) {
                         if (valueNotFound) {
@@ -133,13 +106,13 @@ public class Slices {
                                     return v;
                                 }
                             }
-                            return defaultValue;
+                            return null;
                         }
                         return super.computeValue(map, key, value, false);
                     }
                 };
             }
-            return new SliceWithOpposite<K, V>(rewritePolicy, opposite);
+            return new BasicRemovableSlice<K, V>(rewritePolicy);
         }
     }
 
@@ -153,22 +126,6 @@ public class Slices {
         }
     }
 
-    public static class SliceWithOpposite<K, V> extends BasicRemovableSlice<K, V> {
-        private final WritableSlice<? super V, ? super K> opposite;
-
-        public SliceWithOpposite(RewritePolicy rewritePolicy, WritableSlice<? super V, ? super K> opposite) {
-            super(rewritePolicy);
-            this.opposite = opposite;
-        }
-
-        @Override
-        public void afterPut(MutableSlicedMap map, K key, V value) {
-            if (opposite != null) {
-                map.put(opposite, value, key);
-            }
-        }
-    }
-
     public static class SetSlice<K> extends BasicRemovableSlice<K, Boolean> {
 
         protected SetSlice(RewritePolicy rewritePolicy) {

compiler/tests/org/jetbrains/kotlin/util/slicedMap/TrackingSliceMapTest.java

@@ -31,18 +31,6 @@ public class TrackingSliceMapTest extends TestCase {
         assertEquals(42, (int) answer);
     }
 
-    public void testOppositeSlice() {
-        WritableSlice<Integer, String> COLOR_NAME = Slices.<Integer, String>sliceBuilder().setDebugName("COLOR_NAME").build();
-        WritableSlice<String, Integer> NAME_COLOR = Slices.<String, Integer>sliceBuilder().setOpposite(COLOR_NAME).setDebugName("NAME_COLOR").build();
-
-        BindingTraceContext traceContext = BindingTraceContext.createTraceableBindingTrace();
-
-        traceContext.record(NAME_COLOR, "RED", 0xff0000);
-        String redName = traceContext.get(COLOR_NAME, 0xff0000);
-
-        assertEquals("RED", redName);
-    }
-
     public void testFurtherSlices() {
         WritableSlice<String, Integer> NAME_COLOR = Slices.<String, Integer>sliceBuilder().setDebugName("NAME_COLOR").build();