Port remaning Desugar errors to new scheme

Author: ausmarton

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -946,9 +946,11 @@ object desugar {
         }
       case mdef: Import =>
         mdef
-      case mdef =>
+      case mdef if !mdef.isEmpty => {
         ctx.error(ExtensionCanOnlyHaveDefs(mdef), mdef.sourcePos)
         mdef
+      }
+      case mdef => mdef
     }
   }
 
@@ -1001,7 +1003,7 @@ object desugar {
             case Some(DefDef(name, _, (vparam :: _) :: _, _, _)) =>
               s"extension_${name}_${inventTypeName(vparam.tpt)}"
             case _ =>
-              ctx.error(i"anonymous instance must implement a type or have at least one extension method", impl.sourcePos)
+              ctx.error(AnonymousInstanceCannotBeEmpty(impl), impl.sourcePos)
               nme.ERROR.toString
         else
           impl.parents.map(inventTypeName(_)).mkString("given_", "_", "")
@@ -1798,7 +1800,7 @@ object desugar {
           def traverse(tree: untpd.Tree)(implicit ctx: Context): Unit = tree match {
             case Splice(expr) => collect(expr)
             case TypSplice(expr) =>
-              ctx.error("Type splices cannot be used in val patterns. Consider using `match` instead.", tree.sourcePos)
+              ctx.error(TypeSpliceInValPattern(expr), tree.sourcePos)
             case _ => traverseChildren(tree)
           }
         }.traverse(expr)

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

@@ -161,7 +161,9 @@ enum ErrorMessageID extends java.lang.Enum[ErrorMessageID] {
     NoExtensionMethodAllowedID,
     ExtensionMethodCannotHaveTypeParamsID,
     ExtensionCanOnlyHaveDefsID,
-    UnexpectedPatternForSummonFromID
+    UnexpectedPatternForSummonFromID,
+    AnonymousInstanceCannotBeEmptyID,
+    TypeSpliceInValPatternID
 
   def errorNumber = ordinal - 2
 }

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

@@ -2526,4 +2526,26 @@ object messages {
            | }
            |""".stripMargin
   }
+
+  case class AnonymousInstanceCannotBeEmpty(impl:  untpd.Template)(implicit ctx: Context)
+    extends Message(AnonymousInstanceCannotBeEmptyID) {
+    val kind: String = "Syntax"
+    val msg: String = i"anonymous instance must implement a type or have at least one extension method"
+
+    val explanation: String =
+      em"""|Anonymous instances cannot be defined with an empty body. The block
+           |`${impl.show}` should either contain an implemented type or at least one extension method.
+           |""".stripMargin
+  }
+
+  case class TypeSpliceInValPattern(expr:  untpd.Tree)(implicit ctx: Context)
+    extends Message(TypeSpliceInValPatternID) {
+    val kind: String = "Syntax"
+    val msg: String = "Type splices cannot be used in val patterns. Consider using `match` instead."
+
+    val explanation: String =
+      em"""|Type splice: `$$${expr.show}` cannot be used in a `val` pattern. Consider rewriting the `val` pattern
+           |as a `match` with a corresponding `case` to replace the `val`.
+           |""".stripMargin
+  }
 }

compiler/test/dotty/tools/dotc/reporting/ErrorMessagesTests.scala

@@ -1893,4 +1893,38 @@ class ErrorMessagesTests extends ErrorMessagesTest {
         assertEquals("Only methods allowed here, since collective parameters are given", errorMsg)
         assertEquals("val v: T = t", x.show)
       }
+
+  @Test def anonymousInstanceMustImplementAType =
+    checkMessagesAfter(RefChecks.name) {
+      """object Test {
+        |  extension on[T] (t: T) { }
+        |}
+      """.stripMargin
+    }
+      .expect { (ictx, messages) ⇒
+        implicit val ctx: Context = ictx
+        assertMessageCount(1, messages)
+        val errorMsg = messages.head.msg
+        assertEquals("anonymous instance must implement a type or have at least one extension method", errorMsg)
+      }
+
+  @Test def typeSplicesInValPatterns =
+    checkMessagesAfter(RefChecks.name) {
+      s"""import scala.quoted._
+         |object Foo {
+         |  def f(using q: QuoteContext) = {
+         |      val t: Type[Int] = ???
+         |      val '[ *:[$$t] ] = ???
+         |  }
+         |}
+      """.stripMargin
+    }
+      .expect { (ictx, messages) ⇒
+        implicit val ctx: Context = ictx
+        assertMessageCount(1, messages)
+        val errorMsg = messages.head.msg
+        val TypeSpliceInValPattern(x) :: Nil = messages
+        assertEquals("Type splices cannot be used in val patterns. Consider using `match` instead.", errorMsg)
+        assertEquals("t", x.show)
+      }
 }

tests/neg/anonymous-instance-cannot-be-empty.check

@@ -0,0 +1,6 @@
+-- [E154] Syntax Error: tests/neg/anonymous-instance-cannot-be-empty.scala:2:15 ----------------------------------------
+2 |  extension on[T] (t: T) { } // error
+  |               ^^^^^^^^
+  |               anonymous instance must implement a type or have at least one extension method
+
+longer explanation available when compiling with `-explain`

tests/neg/anonymous-instance-cannot-be-empty.scala

@@ -0,0 +1,3 @@
+object Test {
+  extension on[T] (t: T) { } // error
+}

tests/neg/type-splice-in-val-pattern.check

@@ -0,0 +1,6 @@
+-- [E155] Syntax Error: tests/neg/type-splice-in-val-pattern.scala:5:14 ------------------------------------------------
+5 |    val '[ *:[$$t] ] = ??? // error
+  |              ^^^
+  |              Type splices cannot be used in val patterns. Consider using `match` instead.
+
+longer explanation available when compiling with `-explain`

tests/neg/type-splice-in-val-pattern.scala

@@ -0,0 +1,7 @@
+import scala.quoted._
+object Foo {
+  def f(using q: QuoteContext) = {
+    val t: Type[Int] = ???
+    val '[ *:[$$t] ] = ??? // error
+  }
+}