Control whether a variable is changed in a loop (at this moment there is only a problem with variables captured in a closure)

mglukhikh · mglukhikh · commit cd531d83e793 · 2015-04-10T15:33:33.000+03:00
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/DataFlowInfo.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/DataFlowInfo.java
@@ -49,6 +49,13 @@ public interface DataFlowInfo {
     @NotNull
     Set<JetType> getPossibleTypes(@NotNull DataFlowValue key);
 
+    /**
+     * Call this function to clear all data flow information about
+     * the given data flow value.
+     */
+    @NotNull
+    DataFlowInfo clearValueInfo(@NotNull DataFlowValue value);
+
     /**
      * Call this function when b is assigned to a
      */
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/DelegatingDataFlowInfo.java b/compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/smartcasts/DelegatingDataFlowInfo.java
@@ -29,7 +29,7 @@
 import static org.jetbrains.kotlin.resolve.calls.smartcasts.Nullability.NOT_NULL;
 
 /* package */ class DelegatingDataFlowInfo implements DataFlowInfo {
-    private static final ImmutableMap<DataFlowValue,Nullability> EMPTY_NULLABILITY_INFO = ImmutableMap.of();
+    private static final ImmutableMap<DataFlowValue, Nullability> EMPTY_NULLABILITY_INFO = ImmutableMap.of();
     private static final SetMultimap<DataFlowValue, JetType> EMPTY_TYPE_INFO = newTypeInfo();
     private static final DataFlowInfo EMPTY_INFO_WITH_JUMP = new DelegatingDataFlowInfo(null, EMPTY_NULLABILITY_INFO,
                                                                                         EMPTY_TYPE_INFO, true);
@@ -40,22 +40,42 @@
     @NotNull
     private final ImmutableMap<DataFlowValue, Nullability> nullabilityInfo;
 
-    /** Also immutable */
+    /**
+     * Also immutable
+     */
     @NotNull
     private final SetMultimap<DataFlowValue, JetType> typeInfo;
 
+    /**
+     * Value for which type info was cleared at this point
+     * so parent type info should not be in use
+     */
+    @Nullable
+    private final DataFlowValue valueWithoutTypeInfo;
+
     private final boolean jumpPossible;
 
     /* package */ DelegatingDataFlowInfo(
             @Nullable DataFlowInfo parent,
             @NotNull ImmutableMap<DataFlowValue, Nullability> nullabilityInfo,
             @NotNull SetMultimap<DataFlowValue, JetType> typeInfo,
             boolean jumpPossible
+    ) {
+        this(parent, nullabilityInfo, typeInfo, jumpPossible, null);
+    }
+
+    /* package */ DelegatingDataFlowInfo(
+            @Nullable DataFlowInfo parent,
+            @NotNull ImmutableMap<DataFlowValue, Nullability> nullabilityInfo,
+            @NotNull SetMultimap<DataFlowValue, JetType> typeInfo,
+            boolean jumpPossible,
+            @Nullable DataFlowValue valueWithoutTypeInfo
     ) {
         this.parent = parent;
         this.nullabilityInfo = nullabilityInfo;
         this.typeInfo = typeInfo;
         this.jumpPossible = jumpPossible;
+        this.valueWithoutTypeInfo = valueWithoutTypeInfo;
     }
 
     @Override
@@ -80,10 +100,16 @@ public Map<DataFlowValue, Nullability> getCompleteNullabilityInfo() {
     @NotNull
     public SetMultimap<DataFlowValue, JetType> getCompleteTypeInfo() {
         SetMultimap<DataFlowValue, JetType> result = newTypeInfo();
+        Set<DataFlowValue> resultCompleted = new LinkedHashSet<DataFlowValue>();
         DelegatingDataFlowInfo info = this;
         while (info != null) {
             for (DataFlowValue key : info.typeInfo.keySet()) {
-                result.putAll(key, info.typeInfo.get(key));
+                if (!resultCompleted.contains(key)) {
+                    result.putAll(key, info.typeInfo.get(key));
+                }
+            }
+            if (valueWithoutTypeInfo != null) {
+                resultCompleted.add(valueWithoutTypeInfo);
             }
             info = (DelegatingDataFlowInfo) info.parent;
         }
@@ -105,19 +131,25 @@ public Nullability getNullability(@NotNull DataFlowValue key) {
                key.getImmanentNullability();
     }
 
-    private boolean putNullability(@NotNull Map<DataFlowValue, Nullability> map, @NotNull DataFlowValue value, @NotNull Nullability nullability) {
+    private boolean putNullability(
+            @NotNull Map<DataFlowValue, Nullability> map,
+            @NotNull DataFlowValue value,
+            @NotNull Nullability nullability
+    ) {
         if (!value.isStableIdentifier() && !value.isLocalVariable()) return false;
         map.put(value, nullability);
         return nullability != getNullability(value);
     }
 
     @NotNull
     private Set<JetType> getDirectlyPossibleTypes(@NotNull DataFlowValue key) {
+        if (key == valueWithoutTypeInfo) {
+            return EMPTY_TYPE_INFO.get(key);
+        }
         Set<JetType> theseTypes = typeInfo.get(key);
-        Set<JetType> types = parent instanceof DelegatingDataFlowInfo ?
-                             Sets.union(theseTypes, ((DelegatingDataFlowInfo)parent).getDirectlyPossibleTypes(key)) :
-                             theseTypes;
-        return types;
+        return parent instanceof DelegatingDataFlowInfo ?
+               Sets.union(theseTypes, ((DelegatingDataFlowInfo) parent).getDirectlyPossibleTypes(key)) :
+               theseTypes;
     }
 
     @Override
@@ -140,6 +172,30 @@ public Set<JetType> getPossibleTypes(@NotNull DataFlowValue key) {
         return enrichedTypes;
     }
 
+    /**
+     * Call this function to clear all data flow information about
+     * the given data flow value.
+     *
+     * @param value
+     */
+    @NotNull
+    @Override
+    public DataFlowInfo clearValueInfo(@NotNull DataFlowValue value) {
+        Map<DataFlowValue, Nullability> builder = Maps.newHashMap();
+        boolean changed = putNullability(builder, value, Nullability.UNKNOWN);
+        // We want to clear all these types
+        changed |= !getDirectlyPossibleTypes(value).isEmpty();
+        return !changed
+               ? this
+               : new DelegatingDataFlowInfo(
+                       this,
+                       ImmutableMap.copyOf(builder),
+                       EMPTY_TYPE_INFO,
+                       jumpPossible,
+                       value
+               );
+    }
+
     @NotNull
     @Override
     public DataFlowInfo assign(@NotNull DataFlowValue a, @NotNull DataFlowValue b) {
@@ -177,13 +233,13 @@ public DataFlowInfo equate(@NotNull DataFlowValue a, @NotNull DataFlowValue b) {
         changed |= !newTypeInfo.isEmpty();
 
         return !changed
-                    ? this
-                    : new DelegatingDataFlowInfo(
-                            this,
-                            ImmutableMap.copyOf(builder),
-                            newTypeInfo.isEmpty() ? EMPTY_TYPE_INFO : newTypeInfo,
-                            jumpPossible
-                    );
+               ? this
+               : new DelegatingDataFlowInfo(
+                       this,
+                       ImmutableMap.copyOf(builder),
+                       newTypeInfo.isEmpty() ? EMPTY_TYPE_INFO : newTypeInfo,
+                       jumpPossible
+               );
     }
 
     @NotNull
@@ -254,7 +310,7 @@ public DataFlowInfo and(@NotNull DataFlowInfo otherInfo) {
         SetMultimap<DataFlowValue, JetType> myTypeInfo = getCompleteTypeInfo();
         SetMultimap<DataFlowValue, JetType> otherTypeInfo = other.getCompleteTypeInfo();
         if (nullabilityMapBuilder.isEmpty() && containsAll(myTypeInfo, otherTypeInfo)) {
-            return otherInfo.isJumpPossible() ? jump(): this;
+            return otherInfo.isJumpPossible() ? jump() : this;
         }
 
         return new DelegatingDataFlowInfo(this, ImmutableMap.copyOf(nullabilityMapBuilder), otherTypeInfo,
@@ -297,7 +353,8 @@ public DataFlowInfo or(@NotNull DataFlowInfo otherInfo) {
             return (jumpPossible || otherInfo.isJumpPossible()) ? EMPTY_INFO_WITH_JUMP : EMPTY;
         }
 
-        return new DelegatingDataFlowInfo(null, ImmutableMap.copyOf(nullabilityMapBuilder), newTypeInfo, jumpPossible || otherInfo.isJumpPossible());
+        return new DelegatingDataFlowInfo(null, ImmutableMap.copyOf(nullabilityMapBuilder), newTypeInfo,
+                                          jumpPossible || otherInfo.isJumpPossible());
     }
 
     @NotNull
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingVisitor.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/ControlStructureTypingVisitor.java
@@ -197,6 +197,11 @@ public JetTypeInfo visitWhileExpression(JetWhileExpression expression, Expressio
 
         ExpressionTypingContext context = contextWithExpectedType.replaceExpectedType(NO_EXPECTED_TYPE).replaceContextDependency(
                 INDEPENDENT);
+        // Preliminary analysis
+        PreliminaryLoopVisitor loopVisitor = new PreliminaryLoopVisitor(expression, context);
+        loopVisitor.launch();
+        context = context.replaceDataFlowInfo(loopVisitor.clearDataFlowInfoForAssignedExpressions());
+
         JetExpression condition = expression.getCondition();
         DataFlowInfo dataFlowInfo = checkCondition(context.scope, condition, context);
 
@@ -275,6 +280,10 @@ public JetTypeInfo visitDoWhileExpression(JetDoWhileExpression expression, Expre
                 contextWithExpectedType.replaceExpectedType(NO_EXPECTED_TYPE).replaceContextDependency(INDEPENDENT);
         JetExpression body = expression.getBody();
         JetScope conditionScope = context.scope;
+        // Preliminary analysis
+        PreliminaryLoopVisitor loopVisitor = new PreliminaryLoopVisitor(expression, context);
+        loopVisitor.launch();
+        context = context.replaceDataFlowInfo(loopVisitor.clearDataFlowInfoForAssignedExpressions());
         // Here we must record data flow information at the end of the body (or at the first jump, to be precise) and
         // .and it with entrance data flow information, because do-while body is executed at least once
         // See KT-6283
@@ -331,6 +340,11 @@ public JetTypeInfo visitForExpression(JetForExpression expression, ExpressionTyp
 
         ExpressionTypingContext context =
                 contextWithExpectedType.replaceExpectedType(NO_EXPECTED_TYPE).replaceContextDependency(INDEPENDENT);
+        // Preliminary analysis
+        PreliminaryLoopVisitor loopVisitor = new PreliminaryLoopVisitor(expression, context);
+        loopVisitor.launch();
+        context = context.replaceDataFlowInfo(loopVisitor.clearDataFlowInfoForAssignedExpressions());
+
         JetExpression loopRange = expression.getLoopRange();
         JetType expectedParameterType = null;
         DataFlowInfo dataFlowInfo = context.dataFlowInfo;
diff --git a/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/PreliminaryLoopVisitor.java b/compiler/frontend/src/org/jetbrains/kotlin/types/expressions/PreliminaryLoopVisitor.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.types.expressions;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.kotlin.descriptors.impl.LocalVariableDescriptor;
+import org.jetbrains.kotlin.lexer.JetTokens;
+import org.jetbrains.kotlin.name.Name;
+import org.jetbrains.kotlin.psi.*;
+import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfo;
+import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowValue;
+import org.jetbrains.kotlin.resolve.calls.smartcasts.Nullability;
+
+import java.util.*;
+
+/**
+ * The purpose of this class is to find all variable assignments
+ * <b>before</b> loop analysis
+ */
+class PreliminaryLoopVisitor extends JetTreeVisitor<Void> {
+
+    // loop under analysis
+    private final JetLoopExpression loopExpression;
+
+    private final ExpressionTypingContext context;
+
+    private Set<Name> assignedNames = new LinkedHashSet<Name>();
+
+    public PreliminaryLoopVisitor(JetLoopExpression loopExpression, ExpressionTypingContext context) {
+        this.loopExpression = loopExpression;
+        this.context = context;
+    }
+
+    public void launch() {
+        loopExpression.accept(this, null);
+    }
+
+    public DataFlowInfo clearDataFlowInfoForAssignedExpressions() {
+        DataFlowInfo dataFlowInfo = context.dataFlowInfo;
+        Map<DataFlowValue, Nullability> nullabilityMap = dataFlowInfo.getCompleteNullabilityInfo();
+        Set<DataFlowValue> valueSetToClear = new LinkedHashSet<DataFlowValue>();
+        for (DataFlowValue value: nullabilityMap.keySet()) {
+            // Only local variables which are not stable are under interest
+            if (value.isStableIdentifier() || !value.isLocalVariable())
+                continue;
+            if (value.getId() instanceof LocalVariableDescriptor) {
+                LocalVariableDescriptor descriptor = (LocalVariableDescriptor)value.getId();
+                if (assignedNames.contains(descriptor.getName())) {
+                    valueSetToClear.add(value);
+                }
+            }
+        }
+        for (DataFlowValue valueToClear: valueSetToClear) {
+            dataFlowInfo = dataFlowInfo.clearValueInfo(valueToClear);
+        }
+        return dataFlowInfo;
+    }
+
+    @Override
+    public Void visitLoopExpression(@NotNull JetLoopExpression loopExpression, Void arg) {
+        return super.visitLoopExpression(loopExpression, arg);
+    }
+
+    @Override
+    public Void visitBinaryExpression(@NotNull JetBinaryExpression binaryExpression, Void arg) {
+        if (binaryExpression.getOperationToken() == JetTokens.EQ && binaryExpression.getLeft() instanceof JetNameReferenceExpression) {
+            assignedNames.add(((JetNameReferenceExpression) binaryExpression.getLeft()).getReferencedNameAsName());
+        }
+        return null;
+    }
+
+}
