Handle by-name types better

Author: Blaisorblade

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -768,9 +768,16 @@ object Parsers {
             accept(RPAREN)
             if (imods.is(Implicit) || isValParamList || in.token == ARROW) functionRest(ts)
             else {
-              for (t <- ts)
-                if (t.isInstanceOf[ByNameTypeTree])
-                  syntaxError(ByNameParameterNotSupported())
+              val ts1 =
+                for (t <- ts) yield {
+                  t match {
+                    case t@ByNameTypeTree(t1) =>
+                      syntaxError(ByNameParameterNotSupported(t), t.pos)
+                      t1
+                    case _ =>
+                      t
+                  }
+                }
               val tuple = atPos(start) { makeTupleOrParens(ts) }
               infixTypeRest(
                 refinedTypeRest(

compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala

@@ -696,10 +696,10 @@ object messages {
     }
   }
 
-  case class ByNameParameterNotSupported()(implicit ctx: Context)
+  case class ByNameParameterNotSupported(tpe: untpd.TypTree)(implicit ctx: Context)
   extends Message(ByNameParameterNotSupportedID) {
     val kind = "Syntax"
-    val msg = "By-name parameter type not allowed here."
+    val msg = hl"By-name parameter type ${tpe} not allowed here."
 
     val explanation =
       hl"""|By-name parameters act like functions that are only evaluated when referenced,

tests/neg/i4373.scala

@@ -21,5 +21,13 @@ object Test {
 
   // Open questions:
   type T5 = TypeConstr[_ { type S }] // error
-  type T5 = TypeConstr[_[Int]] // error
+  type T6 = TypeConstr[_[Int]] // error
+
+  // expression types
+  type T7 = (=> Int) | (Int => Int) // error
+  type T8 = (=> Int) & (Int => Int) // error
+  type T9 = (=> Int) with (Int => Int) // error
+  type T10 = (Int => Int) | (=> Int) // error
+  type T11 = (Int => Int) & (=> Int) // error
+  type T12 = (Int => Int) with (=> Int) // error
 }