Don't try to simplify & / | types written as types

We should leave an explicit & or | type as an AndType or OrType.
Failure to do this led to cyclic references when compiling stdlib.

Question to resolve: Should we disable all sorts of simplifications
when compiling a type tree?

Author: odersky

compiler/src/dotty/tools/dotc/core/TypeOps.scala

@@ -115,9 +115,9 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
       tp.derivedRefinedType(simplify(tp.parent, theMap), tp.refinedName, simplify(tp.refinedInfo, theMap))
     case tp: TypeAlias =>
       tp.derivedTypeAlias(simplify(tp.alias, theMap))
-    case AndType(l, r) =>
+    case AndType(l, r) if !ctx.mode.is(Mode.Type) =>
       simplify(l, theMap) & simplify(r, theMap)
-    case OrType(l, r) =>
+    case OrType(l, r) if !ctx.mode.is(Mode.Type) =>
       simplify(l, theMap) | simplify(r, theMap)
     case _ =>
       (if (theMap != null) theMap else new SimplifyMap).mapOver(tp)

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

@@ -468,10 +468,10 @@ trait TypeAssigner {
     tree.withType(ref.tpe)
 
   def assignType(tree: untpd.AndTypeTree, left: Tree, right: Tree)(implicit ctx: Context) =
-    tree.withType(inSameUniverse(_ & _, left.tpe, right, "an `&`"))
+    tree.withType(inSameUniverse(AndType(_, _), left.tpe, right, "an `&`"))
 
   def assignType(tree: untpd.OrTypeTree, left: Tree, right: Tree)(implicit ctx: Context) =
-    tree.withType(inSameUniverse(_ | _, left.tpe, right, "an `|`"))
+    tree.withType(inSameUniverse(OrType(_, _), left.tpe, right, "an `|`"))
 
   /** Assign type of RefinedType.
    *  Refinements are typed as if they were members of refinement class `refineCls`.