1 files changed, 10 insertions, 55 deletions

diff --git a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/ExpressionCompatibilityConstraint.java b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/ExpressionCompatibilityConstraint.java
index 82b320ae99f3..b59cf70bdb69 100644
--- a/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/ExpressionCompatibilityConstraint.java
+++ b/java/java-psi-impl/src/com/intellij/psi/impl/source/resolve/graphInference/constraints/ExpressionCompatibilityConstraint.java
@@ -19,16 +19,12 @@ import com.intellij.psi.*;
 import com.intellij.psi.impl.source.resolve.graphInference.InferenceSession;
 import com.intellij.psi.impl.source.resolve.graphInference.InferenceVariable;
 import com.intellij.psi.impl.source.resolve.graphInference.PsiPolyExpressionUtil;
-import com.intellij.psi.impl.source.tree.java.PsiMethodCallExpressionImpl;
 import com.intellij.psi.infos.MethodCandidateInfo;
 import com.intellij.psi.util.PsiUtil;
 import com.intellij.psi.util.TypeConversionUtil;
-import com.intellij.util.containers.ContainerUtil;
-import com.intellij.util.containers.HashSet;
 import org.jetbrains.annotations.NotNull;
 
-import java.util.Collection;
-import java.util.Iterator;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Set;
 
@@ -94,7 +90,11 @@ public class ExpressionCompatibilityConstraint extends InputOutputConstraintForm
         if (method != null && !method.isConstructor()) {
           returnType = method.getReturnType();
           if (returnType != null) {
-            typeParams = method.getTypeParameters();
+            List<PsiTypeParameter> params = new ArrayList<PsiTypeParameter>();
+            for (PsiTypeParameter parameter : PsiUtil.typeParametersIterable(method)) {
+              params.add(parameter);
+            }
+            typeParams = params.toArray(new PsiTypeParameter[params.size()]);
           }
         } else if (myExpression instanceof PsiNewExpression) {  //default constructor
           final PsiJavaCodeReferenceElement classReference = ((PsiNewExpression)myExpression).getClassOrAnonymousClassReference();
@@ -108,38 +108,8 @@ public class ExpressionCompatibilityConstraint extends InputOutputConstraintForm
         }
 
         if (typeParams != null) {
-
-          final Set<PsiTypeParameter> oldBounds = ContainerUtil.newHashSet(session.getParamsToInfer());
-          final boolean sameMethodCall = session.initBounds(myExpression, typeParams);
-          PsiSubstitutor substitutor = PsiSubstitutor.EMPTY;
-          final HashSet<InferenceVariable> variables = new HashSet<InferenceVariable>();
-          session.collectDependencies(returnType, variables);
-          final PsiTypeParameter[] params = new PsiTypeParameter[typeParams.length];
-          for (int i = 0; i < typeParams.length; i++) {
-            if (variables.contains(session.getInferenceVariable(typeParams[i]))) {
-              params[i] = JavaPsiFacade.getElementFactory(myExpression.getProject()).createTypeParameterFromText("copyOf" + myExpression.hashCode() + typeParams[i].getName(), null);
-              substitutor = substitutor.put(typeParams[i], JavaPsiFacade.getElementFactory(myExpression.getProject()).createType(params[i]));
-            }
-            else {
-              params[i] = typeParams[i];
-            }
-          }
-          PsiSubstitutor siteSubstitutor = PsiSubstitutor.EMPTY;
-          if (method != null && !method.isConstructor()) {
-            if (resolveResult instanceof MethodCandidateInfo) {
-              siteSubstitutor = ((MethodCandidateInfo)resolveResult).getSiteSubstitutor();
-            }
-            else if (candidateProperties != null) {
-              siteSubstitutor = candidateProperties.getSubstitutor();
-            }
-          }
-          for (PsiTypeParameter typeParameter : siteSubstitutor.getSubstitutionMap().keySet()) {
-            substitutor = substitutor.put(typeParameter, substitutor.substitute(siteSubstitutor.substitute(typeParameter)));
-          }
-
-          final Collection<PsiTypeParameter> params1 = session.getTypeParams();
-          final InferenceSession callSession = new InferenceSession(params, substitutor, myExpression.getManager(), myExpression);
-          callSession.initBounds(session.getContext(), params1.toArray(new PsiTypeParameter[params1.size()]));
+          final InferenceSession callSession = new InferenceSession(typeParams, PsiSubstitutor.EMPTY, myExpression.getManager(), myExpression);
+          callSession.propagateVariables(session.getInferenceVariables());
           if (method != null) {
             final PsiExpression[] args = argumentList.getExpressions();
             final PsiParameter[] parameters = method.getParameterList().getParameters();
@@ -150,27 +120,12 @@ public class ExpressionCompatibilityConstraint extends InputOutputConstraintForm
           if (!accepted) {
             return false;
           }
-          callSession.registerReturnTypeConstraints(
-            method != null && !PsiUtil.isRawSubstitutor(method, siteSubstitutor) ? siteSubstitutor.substitute(returnType) : returnType,
-            substitutor.substitute(returnType));
+          callSession.registerReturnTypeConstraints(returnType, myT);
           if (callSession.repeatInferencePhases(true)) {
-            final Collection<InferenceVariable> inferenceVariables = callSession.getInferenceVariables();
-            if (sameMethodCall) {
-              for (Iterator<InferenceVariable> iterator = inferenceVariables.iterator(); iterator.hasNext(); ) {
-                InferenceVariable variable = iterator.next();
-                if (oldBounds.contains(variable.getParameter())) {
-                  iterator.remove();
-                }
-              }
-            }
-            session.liftBounds(myExpression, inferenceVariables);
+            session.registerNestedSession(callSession);
           } else {
             return false;
           }
-          final PsiType capturedReturnType = myExpression instanceof PsiMethodCallExpression
-                                             ? PsiMethodCallExpressionImpl.captureReturnType((PsiMethodCallExpression)myExpression, method, returnType, substitutor)
-                                             : substitutor.substitute(returnType);
-          constraints.add(new TypeCompatibilityConstraint(myT, capturedReturnType));
         }
       }
       return true;