Move phantom universe checks from Typer to TypeAssigner.

Author: nicolasstucki

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

@@ -417,8 +417,10 @@ trait TypeAssigner {
   def assignType(tree: untpd.Inlined, bindings: List[Tree], expansion: Tree)(implicit ctx: Context) =
     tree.withType(avoidingType(expansion, bindings))
 
-  def assignType(tree: untpd.If, thenp: Tree, elsep: Tree)(implicit ctx: Context) =
+  def assignType(tree: untpd.If, thenp: Tree, elsep: Tree)(implicit ctx: Context) = {
+    checkSameUniverse(thenp, elsep, "be combined in branches of if/else", tree.pos)
     tree.withType(thenp.tpe | elsep.tpe)
+  }
 
   def assignType(tree: untpd.Closure, meth: Tree, target: Tree)(implicit ctx: Context) =
     tree.withType(
@@ -428,8 +430,15 @@ trait TypeAssigner {
   def assignType(tree: untpd.CaseDef, body: Tree)(implicit ctx: Context) =
     tree.withType(body.tpe)
 
-  def assignType(tree: untpd.Match, cases: List[CaseDef])(implicit ctx: Context) =
+  def assignType(tree: untpd.Match, cases: List[CaseDef])(implicit ctx: Context) = {
+    if (tree.selector.typeOpt.isPhantom)
+      ctx.error("Cannot pattern match on phantoms", tree.selector.pos)
+    if (cases.nonEmpty) {
+      val head = cases.head
+      cases.tail.foreach(c => checkSameUniverse(head, c, "be combined in branches of a match", c.pos))
+    }
     tree.withType(ctx.typeComparer.lub(cases.tpes))
+  }
 
   def assignType(tree: untpd.Return)(implicit ctx: Context) =
     tree.withType(defn.NothingType)
@@ -449,11 +458,15 @@ trait TypeAssigner {
   def assignType(tree: untpd.SingletonTypeTree, ref: Tree)(implicit ctx: Context) =
     tree.withType(ref.tpe)
 
-  def assignType(tree: untpd.AndTypeTree, left: Tree, right: Tree)(implicit ctx: Context) =
+  def assignType(tree: untpd.AndTypeTree, left: Tree, right: Tree)(implicit ctx: Context) = {
+    checkSameUniverse(left, right, "be combined in `&`", tree.pos)
     tree.withType(left.tpe & right.tpe)
+  }
 
-  def assignType(tree: untpd.OrTypeTree, left: Tree, right: Tree)(implicit ctx: Context) =
+  def assignType(tree: untpd.OrTypeTree, left: Tree, right: Tree)(implicit ctx: Context) = {
+    checkSameUniverse(left, right, "be combined in `|`", tree.pos)
     tree.withType(left.tpe | right.tpe)
+  }
 
   /** Assign type of RefinedType.
    *  Refinements are typed as if they were members of refinement class `refineCls`.
@@ -483,8 +496,10 @@ trait TypeAssigner {
   def assignType(tree: untpd.ByNameTypeTree, result: Tree)(implicit ctx: Context) =
     tree.withType(ExprType(result.tpe))
 
-  def assignType(tree: untpd.TypeBoundsTree, lo: Tree, hi: Tree)(implicit ctx: Context) =
+  def assignType(tree: untpd.TypeBoundsTree, lo: Tree, hi: Tree)(implicit ctx: Context) = {
+    checkSameUniverse(lo, hi, "be combined in type bounds.", tree.pos)
     tree.withType(if (lo eq hi) TypeAlias(lo.tpe) else TypeBounds(lo.tpe, hi.tpe))
+  }
 
   def assignType(tree: untpd.Bind, sym: Symbol)(implicit ctx: Context) =
     tree.withType(NamedType.withFixedSym(NoPrefix, sym))
@@ -529,6 +544,12 @@ trait TypeAssigner {
 
   def assignType(tree: untpd.PackageDef, pid: Tree)(implicit ctx: Context) =
     tree.withType(pid.symbol.valRef)
+
+  private def checkSameUniverse(tree1: Tree, tree2: Tree, relationship: => String, pos: Position)(implicit ctx: Context) = {
+    if (tree1.tpe.topType != tree2.tpe.topType)
+      ctx.error(ex"${tree1.tpe} and ${tree2.tpe} are in different universes. They cannot $relationship", pos)
+  }
+
 }
 
 object TypeAssigner extends TypeAssigner

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

@@ -665,12 +665,6 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     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)
-    if (thenp1.tpe.topType != elsep1.tpe.topType) {
-      ctx.error(s"""if/else cannot have branches with types in different lattices:
-                   |  ${thenp1.tpe.show} of lattice ${thenp1.tpe.topType.show}
-                   |  ${elsep1.tpe.show} of lattice ${elsep1.tpe.topType.show}
-                """.stripMargin, tree.pos)
-    }
     val thenp2 :: elsep2 :: Nil = harmonize(thenp1 :: elsep1 :: Nil)
     assignType(cpy.If(tree)(cond1, thenp2, elsep2), thenp2, elsep2)
   }
@@ -842,8 +836,6 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
         typed(desugar.makeCaseLambda(tree.cases, protoFormals.length, unchecked) withPos tree.pos, pt)
       case _ =>
         val sel1 = typedExpr(tree.selector)
-        if (sel1.tpe.isPhantom)
-          ctx.error("Cannot pattern match on phantoms", sel1.pos)
         val selType = fullyDefinedType(sel1.tpe, "pattern selector", tree.pos).widen
 
         val cases1 = typedCases(tree.cases, selType, pt.notApplied)
@@ -874,15 +866,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       accu(Set.empty, selType)
     }
 
-    val tpdCases = cases mapconserve (typedCase(_, pt, selType, gadtSyms))
-
-    if (tpdCases.nonEmpty) {
-      val top = tpdCases.head.tpe.topType
-      for (tpdCase <- tpdCases if tpdCase.tpe.topType != top)
-        ctx.error(s"Pattern expected case to return a ${top.show} but was ${tpdCase.tpe.show}", tpdCase.pos)
-    }
-
-    tpdCases
+    cases mapconserve (typedCase(_, pt, selType, gadtSyms))
   }
 
   /** Type a case. Overridden in ReTyper, that's why it's separate from
@@ -1672,38 +1656,8 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
 
   def typedExpr(tree: untpd.Tree, pt: Type = WildcardType)(implicit ctx: Context): Tree =
     typed(tree, pt)(ctx retractMode Mode.PatternOrType)
-  def typedType(tree: untpd.Tree, pt: Type = WildcardType)(implicit ctx: Context): Tree = {
-    // todo: retract mode between Type and Pattern?
-
-    /** Check that there are not mixed Any/Phantom.Any types in `&`, `|` and type bounds,
-     *  this includes Phantom.Any of different universes.
-     */
-    def checkedTops(tree: untpd.Tree): Set[Type] = {
-      tree match {
-        case TypeBoundsTree(lo, hi) =>
-          val allTops = checkedTops(hi) union checkedTops(lo)
-          if (allTops.size <= 1) allTops
-          else {
-            ctx.error("Type can not be bounded at the same time by types in different latices: " +
-                allTops.map(_.show).mkString(", "), tree.pos)
-            Set.empty
-          }
-        case untpd.InfixOp(left, op, right) =>
-          val allTops = checkedTops(left) union checkedTops(right)
-          if (allTops.size <= 1) allTops
-          else {
-            ctx.error(s"Can not use ${op.show} mix types of different lattices: " +
-                allTops.map(_.show).mkString(", "), tree.pos)
-            Set.empty
-          }
-        case EmptyTree => Set.empty
-        case _ => Set(tree.typeOpt.topType)
-      }
-    }
-    checkedTops(tree)
-
+  def typedType(tree: untpd.Tree, pt: Type = WildcardType)(implicit ctx: Context): Tree = // todo: retract mode between Type and Pattern?
     typed(tree, pt)(ctx addMode Mode.Type)
-  }
   def typedPattern(tree: untpd.Tree, selType: Type = WildcardType)(implicit ctx: Context): Tree =
     typed(tree, selType)(ctx addMode Mode.Pattern)