java/java-impl/src/com/intellij/codeInsight/guess/impl/ExpressionTypeMemoryState.java

   1 /*
   2  * Copyright 2000-2009 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package com.intellij.codeInsight.guess.impl;
  17
  18 import com.intellij.codeInsight.CodeInsightUtil;
  19 import com.intellij.codeInspection.dataFlow.DfaMemoryStateImpl;
  20 import com.intellij.codeInspection.dataFlow.value.DfaValue;
  21 import com.intellij.codeInspection.dataFlow.value.DfaValueFactory;
  22 import com.intellij.psi.PsiExpression;
  23 import com.intellij.psi.PsiType;
  24 import com.intellij.util.containers.HashMap;
  25 import gnu.trove.THashMap;
  26 import gnu.trove.TObjectHashingStrategy;
  27
  28 import java.util.Map;
  29
  30 /**
  31  * @author peter
  32  */
  33 public class ExpressionTypeMemoryState extends DfaMemoryStateImpl {
  34   public static final TObjectHashingStrategy<PsiExpression> EXPRESSION_HASHING_STRATEGY = new TObjectHashingStrategy<PsiExpression>() {
  35     public int computeHashCode(PsiExpression object) {
  36       return object.getNode().getElementType().hashCode();
  37     }
  38
  39     public boolean equals(PsiExpression o1, PsiExpression o2) {
  40       return CodeInsightUtil.areExpressionsEquivalent(o1, o2);
  41     }
  42   };
  43   private final Map<PsiExpression, PsiType> myStates = new THashMap<PsiExpression, PsiType>(EXPRESSION_HASHING_STRATEGY);
  44
  45   public ExpressionTypeMemoryState(final DfaValueFactory factory) {
  46     super(factory);
  47   }
  48
  49   @Override
  50   protected DfaMemoryStateImpl createNew() {
  51     return new ExpressionTypeMemoryState(getFactory());
  52   }
  53
  54   @Override
  55   public DfaMemoryStateImpl createCopy() {
  56     final ExpressionTypeMemoryState copy = (ExpressionTypeMemoryState)super.createCopy();
  57     copy.myStates.putAll(myStates);
  58     return copy;
  59   }
  60
  61   @Override
  62   public boolean applyCondition(DfaValue dfaCond) {
  63     if (dfaCond instanceof DfaInstanceofValue) {
  64       final DfaInstanceofValue value = (DfaInstanceofValue)dfaCond;
  65       if (!value.isNegated()) {
  66         setExpressionType(value.getExpression(), value.getCastType());
  67       }
  68     }
  69
  70     return super.applyCondition(dfaCond);
  71   }
  72
  73   public Map<PsiExpression, PsiType> getStates() {
  74     return myStates;
  75   }
  76
  77   @Override
  78   public boolean equals(Object o) {
  79     if (this == o) return true;
  80     if (o == null || getClass() != o.getClass()) return false;
  81     if (!super.equals(o)) return false;
  82
  83     ExpressionTypeMemoryState that = (ExpressionTypeMemoryState)o;
  84
  85     if (!myStates.equals(that.myStates)) return false;
  86
  87     return true;
  88   }
  89
  90   @Override
  91   public int hashCode() {
  92     int result = super.hashCode();
  93     result = 31 * result + myStates.hashCode();
  94     return result;
  95   }
  96
  97   @Override
  98   public String toString() {
  99     return super.toString() + " states=[" + new HashMap<PsiExpression, PsiType>(myStates) + "]";
 100   }
 101
 102   public void setExpressionType(PsiExpression expression, PsiType type) {
 103     myStates.put(expression, type);
 104   }
 105 }