Allow user-defined error diagnostics when rewriting

So far, it's very rudimentary. There's a method `typelevel.error`
which produces an error with a constant string argument. To make
this more powerful we need a rewriting framework that interpolates
strings and can report compiler trees and terms in such strings.

Author: odersky

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

@@ -218,6 +218,10 @@ class Definitions {
     lazy val Sys_errorR = SysPackage.moduleClass.requiredMethodRef(nme.error)
     def Sys_error(implicit ctx: Context) = Sys_errorR.symbol
 
+  lazy val TypelevelPackageObjectRef = ctx.requiredModuleRef("scala.typelevel.package")
+    lazy val Typelevel_errorR = TypelevelPackageObjectRef.symbol.requiredMethodRef(nme.error)
+    def Typelevel_error(implicit ctx: Context) = Typelevel_errorR.symbol
+
   /** The `scalaShadowing` package is used to safely modify classes and
    *  objects in scala so that they can be used from dotty. They will
    *  be visible as members of the `scala` package, replacing any objects

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

@@ -425,6 +425,16 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
         expansion
     }
 
+    def issueError() = callValueArgss match {
+      case (msgArg :: Nil) :: Nil =>
+        msgArg.tpe match {
+          case ConstantType(Constant(msg: String)) =>
+            ctx.error(msg, call.pos)
+          case _ =>
+        }
+      case _ =>
+    }
+
     trace(i"inlining $call", inlining, show = true) {
 
       // The normalized bindings collected in `bindingsBuf`
@@ -444,6 +454,8 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
       val (finalBindings, finalExpansion) = dropUnusedDefs(bindingsBuf.toList ++ matchBindings, expansion1)
       val (finalMatchBindings, finalArgBindings) = finalBindings.partition(matchBindings.contains(_))
 
+      if (inlinedMethod == defn.Typelevel_error) issueError()
+
       // Take care that only argument bindings go into `bindings`, since positions are
       // different for bindings from arguments and bindings from body.
       tpd.Inlined(call, finalArgBindings, seq(finalMatchBindings, finalExpansion))

library/src-scala3/scala/typelevel/package.scala

@@ -1,6 +1,10 @@
 package scala
 
 package object typelevel {
+
   erased def erasedValue[T]: T = ???
+
   case class Typed[T](val value: T) { type Type = T }
+
+  rewrite def error(transparent msg: String): Nothing = ???
 }