Fix cutting problem

Test case: orInf.scala. This showed a problem where an `either` operation
had to arbitrarily pick one constraint over another, leading to a type
error down the line. What happened was that a `constrainResult` generated
the constraint

    Set[A] <: Set[String] | Set[Int]

But this constraint cannot be simplified without a cut and a resulting
loss of information. We avoid the problem by not constraining the result
if the prototype is a disjunction.

Author: odersky

src/dotty/tools/dotc/core/TypeComparer.scala

@@ -8,7 +8,7 @@ import StdNames.{nme, tpnme}
 import collection.mutable
 import util.{Stats, DotClass, SimpleMap}
 import config.Config
-import config.Printers.{typr, constr, subtyping}
+import config.Printers.{typr, constr, subtyping, noPrinter}
 import TypeErasure.{erasedLub, erasedGlb}
 import TypeApplications._
 import scala.util.control.NonFatal
@@ -837,8 +837,11 @@ class TypeComparer(initctx: Context) extends DotClass with ConstraintHandling {
     op1 && {
       val leftConstraint = constraint
       constraint = preConstraint
-      if (!(op2 && subsumes(leftConstraint, constraint, preConstraint)))
+      if (!(op2 && subsumes(leftConstraint, constraint, preConstraint))) {
+        if (constr != noPrinter && !subsumes(constraint, leftConstraint, preConstraint))
+          constr.println(i"CUT - prefer $leftConstraint over $constraint")
         constraint = leftConstraint
+      }
       true
     } || op2
   }

src/dotty/tools/dotc/typer/ProtoTypes.scala

@@ -43,6 +43,11 @@ object ProtoTypes {
       isCompatible(normalize(tp, pt)(nestedCtx), pt)(nestedCtx)
     }
 
+    private def disregardProto(pt: Type)(implicit ctx: Context): Boolean = pt.dealias match {
+      case _: OrType => true
+      case pt => pt.isRef(defn.UnitClass)
+    }
+
     /** Check that the result type of the current method
      *  fits the given expected result type.
      */
@@ -54,7 +59,7 @@ object ProtoTypes {
           case _ =>
             true
         }
-      case _: ValueTypeOrProto if !(pt isRef defn.UnitClass) =>
+      case _: ValueTypeOrProto if !disregardProto(pt) =>
         mt match {
           case mt: MethodType =>
             mt.isDependent || isCompatible(normalize(mt, pt), pt)