Adapt tests to restricted meaning of GADTs

In the new implementation, a companion object of an opaque type

  opaque type T = A

only knows that T <: A and that A <: T. By itself that does not
propagate some informations from `A` to `T`. For instance the members
of A are now not the members of T.

tests/pos/opaque-immutable-array.scala

@@ -6,12 +6,12 @@ object ia {
 
   object IArray {
     inline def initialize[A](body: => Array[A]): IArray[A] = body
-    inline def size[A](ia: IArray[A]): Int = ia.length
-    inline def get[A](ia: IArray[A], i: Int): A = ia(i)
+    inline def size[A](ia: IArray[A]): Int = (ia: Array[A]).length
+    inline def get[A](ia: IArray[A], i: Int): A = (ia: Array[A])(i)
 
     // return a sorted copy of the array
     def sorted[A <: AnyRef : math.Ordering](ia: IArray[A]): IArray[A] = {
-      val arr = Arrays.copyOf(ia, ia.length)
+      val arr = Arrays.copyOf(ia, (ia: Array[A]).length)
       scala.util.Sorting.quickSort(arr)
       arr
     }

tests/pos/opaque-propability.scala

@@ -20,9 +20,9 @@ object prob {
       implicitly[Ordering[Double]]
 
     implicit class ProbabilityOps(p1: Probability) extends AnyVal {
-      def unary_~ : Probability = Certain - p1
-      def &(p2: Probability): Probability = p1 * p2
-      def |(p2: Probability): Probability = p1 + p2 - (p1 * p2)
+      def unary_~ : Probability = asDouble(Certain) - p1
+      def &(p2: Probability): Probability = asDouble(p1) * p2
+      def |(p2: Probability): Probability = asDouble(p1) + p2 - (asDouble(p1) * p2)
 
       def isImpossible: Boolean = p1 == Never
       def isCertain: Boolean = p1 == Certain