diff --git a/java/java-psi-api/src/com/intellij/psi/GenericsUtil.java b/java/java-psi-api/src/com/intellij/psi/GenericsUtil.java
index f6637fde49e1..ff3543a37f16 100644
--- a/java/java-psi-api/src/com/intellij/psi/GenericsUtil.java
+++ b/java/java-psi-api/src/com/intellij/psi/GenericsUtil.java
@@ -120,7 +120,7 @@ public class GenericsUtil {
           PsiType mapping2 = subst2.substitute(parameter);
 
           if (mapping1 != null && mapping2 != null) {
-            substitutor = substitutor.put(parameter, getLeastContainingTypeArgument(mapping1, mapping2, compared, manager));
+            substitutor = substitutor.put(parameter, getLeastContainingTypeArgument(mapping1, mapping2, compared, manager, type1.equals(mapping1) && type2.equals(mapping2) ? aSuper : null, parameter));
           }
           else {
             substitutor = substitutor.put(parameter, null);
@@ -150,9 +150,23 @@ public class GenericsUtil {
   private static PsiType getLeastContainingTypeArgument(PsiType type1,
                                                         PsiType type2,
                                                         Set<Pair<PsiType, PsiType>> compared,
-                                                        PsiManager manager) {
+                                                        PsiManager manager,
+                                                        PsiClass nestedLayer, 
+                                                        PsiTypeParameter parameter) {
     Pair<PsiType, PsiType> types = new Pair<PsiType, PsiType>(type1, type2);
-    if (compared.contains(types)) return PsiWildcardType.createUnbounded(manager);
+    if (compared.contains(types)) {
+      if (nestedLayer != null) {
+        PsiSubstitutor subst = PsiSubstitutor.EMPTY;
+        for (PsiTypeParameter param : PsiUtil.typeParametersIterable(nestedLayer)) {
+          subst = subst.put(param, PsiWildcardType.createUnbounded(manager));
+        }
+        subst = subst.put(parameter, getLeastContainingTypeArgument(type1, type2, compared, manager, null, null));
+
+        final PsiClassType boundType = JavaPsiFacade.getInstance(manager.getProject()).getElementFactory().createType(nestedLayer, subst);
+        return PsiWildcardType.createExtends(manager, boundType);
+      }
+      return PsiWildcardType.createUnbounded(manager);
+    }
     compared.add(types);
 
     try {
@@ -180,7 +194,7 @@ public class GenericsUtil {
         }
       }
       else if (type2 instanceof PsiWildcardType) {
-        return getLeastContainingTypeArgument(type2, type1, compared, manager);
+        return getLeastContainingTypeArgument(type2, type1, compared, manager, null, null);
       }
       //Done with wildcards
 
diff --git a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting/IntersectionTypes.java b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting/IntersectionTypes.java
index a197bf02df7b..b201ac5aa7ae 100644
--- a/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting/IntersectionTypes.java
+++ b/java/java-tests/testData/codeInsight/daemonCodeAnalyzer/genericsHighlighting/IntersectionTypes.java
@@ -8,7 +8,7 @@ class Test {
     }
 
     void foo() {
-        <error descr="Incompatible types. Found: 'java.util.List<java.lang.Class<? extends java.io.Serializable & java.lang.Comparable<?>>>', required: 'java.util.List<java.lang.Class<? extends java.io.Serializable>>'">List<Class<? extends Serializable>> l = <warning descr="Unchecked generics array creation for varargs parameter">this.asList</warning>(String.class, Integer.class);</error>
+        <error descr="Incompatible types. Found: 'java.util.List<java.lang.Class<? extends java.io.Serializable & java.lang.Comparable<? extends java.lang.Comparable<?>>>>', required: 'java.util.List<java.lang.Class<? extends java.io.Serializable>>'">List<Class<? extends Serializable>> l = <warning descr="Unchecked generics array creation for varargs parameter">this.asList</warning>(String.class, Integer.class);</error>
         l.size();
         List<? extends Object> objects = this.asList(new String(), new Integer(0));
         objects.size();
@@ -146,7 +146,7 @@ class IDEADEV25515 {
     }
 
     public static final
-    <error descr="Incompatible types. Found: 'java.util.List<java.lang.Class<? extends java.io.Serializable & java.lang.Comparable<?>>>', required: 'java.util.List<java.lang.Class<? extends java.io.Serializable>>'">List<Class<? extends Serializable>> SIMPLE_TYPES =
+    <error descr="Incompatible types. Found: 'java.util.List<java.lang.Class<? extends java.io.Serializable & java.lang.Comparable<? extends java.lang.Comparable<?>>>>', required: 'java.util.List<java.lang.Class<? extends java.io.Serializable>>'">List<Class<? extends Serializable>> SIMPLE_TYPES =
 <warning descr="Unchecked generics array creation for varargs parameter">asList</warning>(String.class, Integer.class ,Long.class, Double.class, /*Date.class,*/
 Boolean.class, Boolean.TYPE /*,String[].class */ /*,BigDecimal.class*/);</error>
 
@@ -179,3 +179,43 @@ public class MaximalType  {
 class M extends MaximalType implements L{}
 class M2 extends MaximalType implements L{}
 /////////////
+
+
+class IDEA67676 {
+  interface I<<warning descr="Type parameter 'T' is never used">T</warning>> {}
+  interface A<T> extends I<A<T>>{}
+  interface Com2<T, U> {
+    void foo(T t, U u);
+  }
+  interface Com1<T> {
+    void foo(T t);
+  }
+
+  abstract class X {
+      abstract <T> T foo(T x, T y);
+
+      void bar(A<A2> x, A<B2> y) {
+          A<? extends Com2<? extends Com2<?, ?>, ? extends Com2<?, ?>>> f = foo(x, y);
+          f.hashCode();
+      }
+
+      void boo(A<A3> x, A<B3> y) {
+          A<? extends Com2<? extends Com2<?, ?>, ? extends Com2<?, ?>>> f = foo(x, y);
+          f.hashCode();
+      }
+
+      void baz(A<A1> x, A<B1> y) {
+          A<? extends Com1<? extends Com1<?>>> f = foo(x, y);
+          f.hashCode();
+      }
+  }
+
+  abstract class A1 implements Com1<A1> {}
+  abstract class B1 implements Com1<B1> {}
+
+  abstract class A2 implements Com2<A2, A2> {}
+  abstract class B2 implements Com2<B2, B2> {}
+
+  abstract class A3 implements Com2<A3, B3> {}
+  abstract class B3 implements Com2<B3, A3> {}
+}
\ No newline at end of file