Update tests specifically about distributing &

Author: EugeneFlesselle

tests/neg-deep-subtype/i11064.scala

@@ -2,6 +2,6 @@ trait Foo[T <: Foo[T]] {
   type I <: Foo[I]
 }
 
-trait Bar[T <: Foo[T]] extends Foo[T] { // error: cyclic
+trait Bar[T <: Foo[T]] extends Foo[T] { // was error: cyclic
   self: T =>
 }

tests/neg/i10256.scala renamed to tests/pos/i10256.scala

@@ -5,5 +5,6 @@ trait Ops[T <: TypedArray[_, T]] {
 }
 
 object Test {
-  def test(ops: Ops[_ <: TypedArray[_, _]]) = ops.typedArray()
+  def test1(ops: Ops[_ <: TypedArray[_, _]]) = ops.typedArray()
+  def test2(ops: Ops[_ <: TypedArray[_ <: AnyRef, _]]) = ops.typedArray() // ok, was error: Recursion limit exceeded.
 }

tests/pos/i11064.scala

@@ -4,20 +4,20 @@ trait B
 trait Covariant[F[+_]] {
   trait G[+X]
 
-  def fx: F[A  &   B] = fy
+  def fx: F[A  &   B] = ???
   def fy: F[A] & F[B] = fx
 
-  def gx: G[A  &   B] = gy
+  def gx: G[A  &   B] = ???
   def gy: G[A] & G[B] = gx
 }
 
 trait Contravariant[F[-_]] {
   trait G[-X]
 
-  def fx: F[A  |   B] = fy
+  def fx: F[A  |   B] = ???
   def fy: F[A] & F[B] = fx
 
-  def gx: G[A  |   B] = gy
+  def gx: G[A  |   B] = ???
   def gy: G[A] & G[B] = gx
 }
 
@@ -28,7 +28,5 @@ trait LiskovViolation[F[+_]] {
 
   def fc1: C     = new C {}
   def fc2: A & B = fc1
-
-  def fy1: F[A & B] = fc1.children
-  def fy2: F[A & B] = fc2.children
+  def fy2: F[A] & F[B] = fc2.children
 }

tests/pos/i5980.scala

@@ -5,8 +5,6 @@ trait Z
 
 abstract class Test {
   def x: Has[X] | (Has[Y] & Has[Z])
-  val y: Has[? >: (X & Y) | (X & Z) <: (X | Y) & (X | Z)] = x
-
   def foo[T <: Has[_]](has: T): T = has
   foo(x)
 }

tests/pos/i7965.scala

@@ -18,8 +18,7 @@ object intersection {
 
 
   class C[-T]
-  def f: C[A] & C[B] = ???
-  def g: C[A | B] = f
+  def g: C[A | B] = ???
   def h: C[A] & C[B] = g
 }
 object Test {
@@ -41,14 +40,3 @@ object Test {
   def fooBA = (??? : B with A).f
   def fooBA1: Int = fooBA
 }
-
-object Test2:
-  class Row[+X]
-  class A
-  class B
-  class C extends Row[A]
-  class D extends Row[B]
-  val x: C & D = ???
-  val y: Row[A & B] = x
-
-