Generalize constraint handling when harmonizing

When harmonizing repeated arguments we needed to backtrack the
constraint. It turns out we need to do the same thing in all other
situations where harmonization takes place.

Author: odersky

compiler/src/dotty/tools/dotc/typer/Applications.scala

@@ -438,16 +438,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
                 addTyped(arg, formal)
               case _ =>
                 val elemFormal = formal.widenExpr.argTypesLo.head
-                val origConstraint = ctx.typerState.constraint
-                var typedArgs = args.map(typedArg(_, elemFormal))
-                val harmonizedArgs = harmonizeArgs(typedArgs)
-                if (harmonizedArgs ne typedArgs) {
-                  ctx.typerState.constraint = origConstraint
-                    // reset constraint, we will re-establish constraint anyway when we
-                    // compare against the seqliteral. The reset is needed
-                    // otherwise pos/harmonize.scala would fail on line 40.
-                  typedArgs = harmonizedArgs
-                }
+                val typedArgs = harmonic(harmonizeArgs)(args.map(typedArg(_, elemFormal)))
                 typedArgs.foreach(addArg(_, elemFormal))
                 makeVarArg(args.length, elemFormal)
             }
@@ -1494,6 +1485,23 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     if (ctx.isAfterTyper) trees else harmonizeWith(trees)(_.tpe, adapt)
   }
 
+  /** Apply a transformation `harmonize` on the results of operation `op`.
+   *  If the result is different (wrt eq) from the original results of `op`,
+   *  revert back to the constraint in force before computing `op`.
+   *  This reset is needed because otherwise the original results might
+   *  have added constraints to type parameters which are no longer
+   *  implied after harmonization. No essential constraints are lost by this because
+   *  the result of harmomization will be compared again with the expected type.
+   *  Test cases where this matters are in pos/harmomize.scala.
+   */
+  def harmonic[T](harmonize: List[T] => List[T])(op: => List[T])(implicit ctx: Context) = {
+    val origConstraint = ctx.typerState.constraint
+    val origElems = op
+    val harmonizedElems = harmonize(origElems)
+    if (harmonizedElems ne origElems) ctx.typerState.constraint = origConstraint
+    harmonizedElems
+  }
+
   /** If all `types` are numeric value types, and they are not all the same type,
    *  pick a common numeric supertype and widen any constant types in `tpes` to it.
    *  If the resulting types are all the same, return them instead of the original ones.

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -674,9 +674,11 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
 
   def typedIf(tree: untpd.If, pt: Type)(implicit ctx: Context): Tree = track("typedIf") {
     val cond1 = typed(tree.cond, defn.BooleanType)
-    val thenp1 = typed(tree.thenp, pt.notApplied)
-    val elsep1 = typed(tree.elsep orElse (untpd.unitLiteral withPos tree.pos), pt.notApplied)
-    val thenp2 :: elsep2 :: Nil = harmonize(thenp1 :: elsep1 :: Nil)
+    val thenp2 :: elsep2 :: Nil = harmonic(harmonize) {
+      val thenp1 = typed(tree.thenp, pt.notApplied)
+      val elsep1 = typed(tree.elsep orElse (untpd.unitLiteral withPos tree.pos), pt.notApplied)
+      thenp1 :: elsep1 :: Nil
+    }
     assignType(cpy.If(tree)(cond1, thenp2, elsep2), thenp2, elsep2)
   }
 
@@ -884,9 +886,9 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
         val sel1 = typedExpr(tree.selector)
         val selType = fullyDefinedType(sel1.tpe, "pattern selector", tree.pos).widen
 
-        val cases1 = typedCases(tree.cases, selType, pt.notApplied)
-        val cases2 = harmonize(cases1).asInstanceOf[List[CaseDef]]
-        assignType(cpy.Match(tree)(sel1, cases2), cases2)
+        val cases1 = harmonic(harmonize)(typedCases(tree.cases, selType, pt.notApplied))
+          .asInstanceOf[List[CaseDef]]
+        assignType(cpy.Match(tree)(sel1, cases1), cases1)
     }
   }
 
@@ -1011,10 +1013,12 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
   }
 
   def typedTry(tree: untpd.Try, pt: Type)(implicit ctx: Context): Try = track("typedTry") {
-    val expr1 = typed(tree.expr, pt.notApplied)
-    val cases1 = typedCases(tree.cases, defn.ThrowableType, pt.notApplied)
+    val expr2 :: cases2x = harmonic(harmonize) {
+      val expr1 = typed(tree.expr, pt.notApplied)
+      val cases1 = typedCases(tree.cases, defn.ThrowableType, pt.notApplied)
+      expr1 :: cases1
+    }
     val finalizer1 = typed(tree.finalizer, defn.UnitType)
-    val expr2 :: cases2x = harmonize(expr1 :: cases1)
     val cases2 = cases2x.asInstanceOf[List[CaseDef]]
     assignType(cpy.Try(tree)(expr2, cases2, finalizer1), expr2, cases2)
   }

tests/pos/harmonize.scala

@@ -55,4 +55,19 @@ object Test {
   val b5: Array[AnyVal] = a5
   val a6 = Array(1.0f, 1234567890)
   val b6: Array[AnyVal] = a6
+
+  def totalDuration(results: List[Long], cond: Boolean): Long =
+    results.map(r => if (cond) r else 0).sum
+  def totalDuration2(results: List[Long], cond: Boolean): Long =
+    results.map{ r =>
+      cond match {
+        case true => r
+        case false => 0
+      }
+    }.sum
+  def totalDuration3(results: List[Long], cond: Boolean): Long =
+    results.map{ r =>
+      try r
+      catch { case ex: Exception => 0 }
+    }.sum
 }