Port all 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_", "_", "")
@@ -1173,10 +1175,9 @@ object desugar {
   def checkModifiers(tree: Tree)(implicit ctx: Context): Tree = tree match {
     case tree: MemberDef =>
       var tested: MemberDef = tree
-      def fail(msg: String) = ctx.error(msg, tree.sourcePos)
       def checkApplicable(flag: Flag, test: MemberDefTest): Unit =
         if (tested.mods.is(flag) && !test.applyOrElse(tree, (md: MemberDef) => false)) {
-          fail(i"modifier `${flag.flagsString}` is not allowed for this definition")
+          ctx.error(ModifierNotAllowedForDefinition(flag), tree.sourcePos)
           tested = tested.withMods(tested.mods.withoutFlags(flag))
         }
       checkApplicable(Opaque, legalOpaque)
@@ -1798,7 +1799,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,10 @@ enum ErrorMessageID extends java.lang.Enum[ErrorMessageID] {
     NoExtensionMethodAllowedID,
     ExtensionMethodCannotHaveTypeParamsID,
     ExtensionCanOnlyHaveDefsID,
-    UnexpectedPatternForSummonFromID
+    UnexpectedPatternForSummonFromID,
+    AnonymousInstanceCannotBeEmptyID,
+    TypeSpliceInValPatternID,
+    ModifierNotAllowedForDefinitionID
 
   def errorNumber = ordinal - 2
 }

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

@@ -2526,4 +2526,34 @@ 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
+  }
+
+  case class ModifierNotAllowedForDefinition(flag: Flag)(implicit ctx: Context)
+    extends Message(ModifierNotAllowedForDefinitionID) {
+    val kind: String = "Syntax"
+    val msg: String = s"Modifier `${flag.flagsString}` is not allowed for this definition"
+
+    val explanation: String = ""
+  }
 }

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

@@ -1893,4 +1893,54 @@ 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)
+      }
+
+  @Test def modifierNotAllowedForDefinition =
+    checkMessagesAfter(RefChecks.name) {
+      """object Test {
+        |  opaque def o: Int = 3
+        |}
+      """.stripMargin
+    }
+      .expect { (ictx, messages) ⇒
+        implicit val ctx: Context = ictx
+        assertMessageCount(1, messages)
+        val errorMsg = messages.head.msg
+        val ModifierNotAllowedForDefinition(x) :: Nil = messages
+        assertEquals("Modifier `opaque` is not allowed for this definition", errorMsg)
+        assertEquals("opaque", x.flagsString)
+      }
 }

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/modifier-not-allowed.check

@@ -0,0 +1,4 @@
+-- [E156] Syntax Error: tests/neg/modifier-not-allowed.scala:2:13 ------------------------------------------------------
+2 |  opaque def o: Int = 3 // error
+  |  ^^^^^^^^^^^^^^^^^^^^^
+  |  Modifier `opaque` is not allowed for this definition

tests/neg/modifier-not-allowed.scala

@@ -0,0 +1,3 @@
+object Test {
+  opaque def o: Int = 3 // 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
+  }
+}