1 files changed, 175 insertions, 0 deletions
diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/SubtypingConstraint.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/SubtypingConstraint.java
new file mode 100644
index 000000000000..64c28d1b462f
--- /dev/null
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/SubtypingConstraint.java
@@ -0,0 +1,175 @@
+/*
+ * Copyright 2000-2013 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 com.intellij.psi.impl.source.resolve.graphInference.constraints;
+
+import com.intellij.psi.*;
+import com.intellij.psi.impl.source.resolve.graphInference.InferenceBound;
+import com.intellij.psi.impl.source.resolve.graphInference.InferenceSession;
+import com.intellij.psi.impl.source.resolve.graphInference.InferenceVariable;
+import com.intellij.psi.util.TypeConversionUtil;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+
+/**
+ * User: anna
+ */
+public class SubtypingConstraint implements ConstraintFormula {
+  private PsiType myS;
+  private PsiType myT;
+  private boolean myIsRefTypes;
+
+  public SubtypingConstraint(PsiType t, PsiType s, boolean isRefTypes) {
+    myT = t;
+    myS = s;
+    myIsRefTypes = isRefTypes;
+  }
+
+  @Override
+  public boolean reduce(InferenceSession session, List<ConstraintFormula> constraints, List<ConstraintFormula> delayedConstraints) {
+    if (myIsRefTypes) {
+      if (session.isProperType(myS) && session.isProperType(myT)) {
+        if (myT == null || myS == null) return myS == myT;
+        return TypeConversionUtil.isAssignable(myT, myS);
+      }
+      InferenceVariable inferenceVariable = session.getInferenceVariable(myS);
+      if (inferenceVariable != null) {
+        inferenceVariable.addBound(myT, InferenceBound.UPPER);
+        return true;
+      }
+      if (PsiType.NULL.equals(myS)) return true;
+      inferenceVariable = session.getInferenceVariable(myT);
+      if (inferenceVariable != null) {
+        inferenceVariable.addBound(myS, InferenceBound.LOWER);
+        return true;
+      }
+      if (myT instanceof PsiArrayType) {
+        if (!(myS instanceof PsiArrayType)) return false; //todo most specific array supertype
+        final PsiType tComponentType = ((PsiArrayType)myT).getComponentType();
+        final PsiType sComponentType = ((PsiArrayType)myS).getComponentType();
+        if (!(tComponentType instanceof PsiPrimitiveType) && !(sComponentType instanceof PsiPrimitiveType)) {
+          constraints.add(new SubtypingConstraint(tComponentType, sComponentType, true));
+          return true;
+        }
+        return sComponentType instanceof PsiPrimitiveType && sComponentType.equals(tComponentType);
+      }
+      if (myT instanceof PsiClassType) {
+        final PsiClassType.ClassResolveResult TResult = ((PsiClassType)myT).resolveGenerics();
+        final PsiClass CClass = TResult.getElement();
+        if (CClass != null) {
+          if (CClass instanceof PsiTypeParameter) {
+            if (myS instanceof PsiIntersectionType) {
+              for (PsiType conjunct : ((PsiIntersectionType)myS).getConjuncts()) {
+                if (myT.equals(conjunct)) return true;
+              }
+            }
+            //todo ((PsiTypeParameter)C).getLowerBound()
+            return false;
+          }
+  
+          if (!(myS instanceof PsiClassType)) return false;
+          PsiClassType.ClassResolveResult SResult = ((PsiClassType)myS).resolveGenerics();
+          PsiClass SClass = SResult.getElement();
+          final PsiSubstitutor tSubstitutor = TResult.getSubstitutor();
+          final PsiSubstitutor sSubstitutor = SClass != null ? TypeConversionUtil.getClassSubstitutor(CClass, SClass, SResult.getSubstitutor()) : null;
+          if (sSubstitutor != null) {
+            for (PsiTypeParameter parameter : CClass.getTypeParameters()) {
+              final PsiType tSubstituted = tSubstitutor.substitute(parameter);
+              final PsiType sSubstituted = sSubstitutor.substituteWithBoundsPromotion(parameter);
+              constraints.add(new SubtypingConstraint(tSubstituted, sSubstituted, false));
+            }
+            return true;
+          }
+        }
+        return false;
+      }
+
+      if (myT instanceof PsiIntersectionType) {
+        for (PsiType conjunct : ((PsiIntersectionType)myT).getConjuncts()) {
+          constraints.add(new SubtypingConstraint(conjunct, myS, true));
+        }
+        return true;
+      }
+
+      if (PsiType.NULL.equals(myT)) return false;
+    } else {
+      if (myT instanceof PsiWildcardType) {
+        final PsiType tBound = ((PsiWildcardType)myT).getBound();
+        if (tBound == null) {
+          return true;
+        }
+        if (((PsiWildcardType)myT).isExtends()) {
+          if (tBound.equalsToText(CommonClassNames.JAVA_LANG_OBJECT)) {
+            return true;
+          }
+          if (myS instanceof PsiWildcardType) {
+            final PsiType sBound = ((PsiWildcardType)myS).getBound();
+            if (sBound != null && ((PsiWildcardType)myS).isExtends()) {
+              constraints.add(new SubtypingConstraint(tBound, sBound, true));
+              return true;
+            }
+          } else {
+            constraints.add(new SubtypingConstraint(tBound, myS, true));
+            return true;
+          }
+          return false;
+        } else {
+          if (myS instanceof PsiWildcardType) {
+            final PsiType sBound = ((PsiWildcardType)myS).getBound();
+            if (sBound != null && ((PsiWildcardType)myS).isSuper()) {
+              constraints.add(new SubtypingConstraint(sBound, tBound, true));
+              return true;
+            }
+          } else {
+            constraints.add(new SubtypingConstraint(myS, tBound, true));
+            return true;
+          }
+        }
+        return false;
+      } else {
+        if (myS instanceof PsiWildcardType) {
+          return false;
+        } else {
+          constraints.add(new SubtypingConstraint(myT, myS, true));
+          return true;
+        }
+      }
+    }
+    return true;
+  }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) return true;
+    if (o == null || getClass() != o.getClass()) return false;
+
+    SubtypingConstraint that = (SubtypingConstraint)o;
+
+    if (myIsRefTypes != that.myIsRefTypes) return false;
+    if (myS != null ? !myS.equals(that.myS) : that.myS != null) return false;
+    if (myT != null ? !myT.equals(that.myT) : that.myT != null) return false;
+
+    return true;
+  }
+
+  @Override
+  public int hashCode() {
+    int result = myS != null ? myS.hashCode() : 0;
+    result = 31 * result + (myT != null ? myT.hashCode() : 0);
+    result = 31 * result + (myIsRefTypes ? 1 : 0);
+    return result;
+  }
+}