Is it possible to emit a dynamically generated compiler error message in inline methods or clauses?

Question

Summoning an instance by means of a method context parameter allows to customize the error message declaratively annotating the parameter with @implicitNotFound which requires a literal string that supports a type placeholder.

import scala.annotation.implicitNotFound
        
inline def singleInhabitantOf[A](using @implicitNotFound("The received type ${A} is not a singleton") voA: ValueOf[A]): A =
   voA.value
    
singleInhabitantOf[Option[Int]] // Compile error: The received type Option[Int] is not a singleton

If instead the summoning is implemented with summonFrom, we can customize the error message imperatively calling the error method which also requires a literal string but has no type placeholder support.

import scala.compiletime.{summonFrom, error}
        
inline def singleInhabitantOf2[A]: A = summonFrom {
    case voA: ValueOf[A] => voA.value
    case _ => error("The received type ${A} is not a singleton")    
}

singleInhabitantOf2[Option[Int]] // compiler error: The received type ${A} is not a singleton

Is there a way, other than using macros, to summon an implicit instance in the body (like summonFrom does) that has type placeholder support or, much better, dynamic string interpolation?

Dmytro Mitin · Accepted Answer · 2024-05-04 10:22:36Z

Many standard inline methods (error, summonFrom, summonInline, constValue etc.) are actually implemented as macros or compiler internals.

For example you seem to have nothing against using error. It's implemented in compiler internals. Suppose it wouldn't be implemented there. Then we'd have to use our own macro

import scala.quoted.{Quotes, Expr, quotes}

inline def error(inline msg: String): Nothing = ${errorImpl('msg)}
def errorImpl(msg: Expr[String])(using Quotes): Expr[Nothing] =
  import quotes.reflect.*
  report.errorAndAbort(msg.valueOrAbort)

There is shapeless3.typeable.Typeable[A].describe but it's not inline, so can't be used in error.

summonFrom { case m: Mirror.Of[A] => error("The received type " + constValue[m.MirroredLabel] + " is not a singleton") } can be used for sealed traits and case classes but not arbitrary A.

I can't find this in standard library (although it's worth to be there) but you can define your own small macro and use it everywhere in ordinary inline methods

// different file
import scala.quoted.{Quotes, Type, Expr}

inline def typeOf[A]: String = ${typeOfImpl[A]}
def typeOfImpl[A: Type](using Quotes): Expr[String] = Expr(Type.show[A])

import scala.compiletime.{summonFrom, error}

// ordinary inline method, not macro
inline def singleInhabitantOf2[A]: A = summonFrom {
  case voA: ValueOf[A] => voA.value
  case _ => error("The received type " + typeOf[A] + " is not a singleton")
}

error argument can't be written as s"The received type ${typeOf[A]} is not a singleton" because interpolated string is not a string literal.

Collectives™ on Stack Overflow

Is it possible to emit a dynamically generated compiler error message in inline methods or clauses?

1 Answer 1

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

Comments

Your Answer

Sign up or log in

Post as a guest

Related