Treat & and | as *left*-associative

While the operators should be associative, they aren't actually guaranteed to
be, so correct pretty-printing will help users.

* PrinterTests: Add first test for TypeTree printing.
* PrinterTests: disable colors, following ErrorMessagesTest.scala.

Author: Blaisorblade

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -161,9 +161,9 @@ class PlainPrinter(_ctx: Context) extends Printer {
         }
         finally openRecs = openRecs.tail
       case AndType(tp1, tp2) =>
-        changePrec(AndTypePrec) { toText(tp1) ~ " & " ~ toText(tp2) }
+        changePrec(AndTypePrec) { toText(tp1) ~ " & " ~ atPrec(AndTypePrec + 1) { toText(tp2) } }
       case OrType(tp1, tp2) =>
-        changePrec(OrTypePrec) { toText(tp1) ~ " | " ~ toText(tp2) }
+        changePrec(OrTypePrec) { toText(tp1) ~ " | " ~ atPrec(OrTypePrec + 1) { toText(tp2) } }
       case tp: ErrorType =>
         s"<error ${tp.msg.msg}>"
       case tp: WildcardType =>

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -375,9 +375,9 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case SingletonTypeTree(ref) =>
         toTextLocal(ref) ~ "." ~ keywordStr("type")
       case AndTypeTree(l, r) =>
-        changePrec(AndTypePrec) { toText(l) ~ " & " ~ toText(r) }
+        changePrec(AndTypePrec) { toText(l) ~ " & " ~ atPrec(AndTypePrec + 1) { toText(r) } }
       case OrTypeTree(l, r) =>
-        changePrec(OrTypePrec) { toText(l) ~ " | " ~ toText(r) }
+        changePrec(OrTypePrec) { toText(l) ~ " | " ~ atPrec(OrTypePrec + 1) { toText(r) } }
       case RefinedTypeTree(tpt, refines) =>
         toTextLocal(tpt) ~ " " ~ blockText(refines)
       case AppliedTypeTree(tpt, args) =>

compiler/test/dotty/tools/dotc/printing/PrinterTests.scala

@@ -1,13 +1,20 @@
 package dotty.tools.dotc.printing
 
 import dotty.tools.DottyTest
-import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.ast.{Trees,tpd}
 import dotty.tools.dotc.core.Names._
 import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core.Decorators._
 import org.junit.Assert.assertEquals
 import org.junit.Test
 
 class PrinterTests extends DottyTest {
+
+  private def newContext = {
+    initialCtx.setSetting(ctx.settings.color, "never")
+  }
+  ctx = newContext
+
   import tpd._
 
   @Test
@@ -24,4 +31,21 @@ class PrinterTests extends DottyTest {
       assertEquals("package object foo", bar.symbol.owner.show)
     }
   }
+
+  @Test
+  def tpTreeInfixOps: Unit = {
+    val source = """
+      |class &&[T,U]
+      |object Foo {
+      |  def bar1: Int && (Boolean | String) = ???
+      |  def bar2: Int & (Boolean | String) = ???
+      |}
+    """.stripMargin
+
+    checkCompile("frontend", source) { (tree, context) =>
+      implicit val ctx = context
+      val bar @ Trees.DefDef(_, _, _, _, _) = tree.find(tree => tree.symbol.name == termName("bar2")).get
+      assertEquals("Int & (Boolean | String)", bar.tpt.show)
+    }
+  }
 }

tests/patmat/andtype-opentype-interaction.check

@@ -3,4 +3,4 @@
 31: Pattern Match Exhaustivity: _: SealedTrait & OpenClass, _: Trait & OpenClass
 35: Pattern Match Exhaustivity: _: SealedTrait & OpenTrait & OpenClass, _: Trait & OpenTrait & OpenClass
 43: Pattern Match Exhaustivity: _: SealedTrait & OpenAbstractClass, _: Trait & OpenAbstractClass
-47: Pattern Match Exhaustivity: _: SealedTrait & OpenClass & OpenTrait & OpenClassSubclass, _: Trait & OpenClass & OpenTrait & OpenClassSubclass
+47: Pattern Match Exhaustivity: _: SealedTrait & OpenClass & (OpenTrait & OpenClassSubclass), _: Trait & OpenClass & (OpenTrait & OpenClassSubclass)

tests/patmat/andtype-refinedtype-interaction.check

@@ -1,6 +1,6 @@
 32: Pattern Match Exhaustivity: _: Trait & C1{x: Int}
-48: Pattern Match Exhaustivity: _: Clazz & (C1 | C2 | T1){x: Int} & (C3 | C4 | T2){x: Int}, _: Trait & (C1 | C2 | T1){x: Int} & (C3 | C4 | T2){x: Int}
-54: Pattern Match Exhaustivity: _: Trait & (C1 | C2 | T1){x: Int} & C3{x: Int}
+48: Pattern Match Exhaustivity: _: Clazz & (C1 | (C2 | T1)){x: Int} & (C3 | (C4 | T2)){x: Int}, _: Trait & (C1 | (C2 | T1)){x: Int} & (C3 | (C4 | T2)){x: Int}
+54: Pattern Match Exhaustivity: _: Trait & (C1 | (C2 | T1)){x: Int} & C3{x: Int}
 65: Pattern Match Exhaustivity: _: Trait & (C1 | C2){x: Int} & (C3 | SubC1){x: Int}
 72: Pattern Match Exhaustivity: _: Trait & (T1 & (C1 | SubC2)){x: Int} & (T2 & (C2 | C3 | SubC1)){x: Int} &
   SubSubC1{x: Int}