// macro.scala
import scala.language.experimental.macros
import scala.reflect.macros.Context

object TestMacro {
  def test[T](t: T): Unit = macro testImpl[T]

  def testImpl[T: c.WeakTypeTag](c: Context)(t: c.Expr[T]): c.Expr[Unit] = {
    c.error(t.tree.pos, "some error")
    c.universe.reify {
      println(t.splice)
    }
  }
}

// test-macro.scala
object Test extends App {

  import TestMacro._

  test[Any] {
    0
  }

}

// test-macro-eval-crash.scala
import scala.reflect.{ClassTag, classTag}

object Test extends App {

  def intercept[T <: Throwable : ClassTag](body: => Any): T = {
    try {
      body
      throw new Exception(s"Exception of type ${classTag[T]} was not thrown")
    } catch {
      case t: Throwable =>
        if (classTag[T].runtimeClass != t.getClass) throw t
        else t.asInstanceOf[T]
    }
  }

  def eval(code: String, compileOptions: String = ""): Any = {
    val m = scala.reflect.runtime.currentMirror
    import scala.tools.reflect.ToolBox
    val tb: ToolBox[scala.reflect.runtime.universe.type] = m.mkToolBox(options = compileOptions)
    tb.eval(tb.parse(code))
  }

  def expectError(errorSnippet: String, compileOptions: String = "")(code: String) {
    val msg = intercept[scala.tools.reflect.ToolBoxError] {
      eval(code, compileOptions)
    }.getMessage
    assert(msg contains errorSnippet, msg)
  }

  expectError("some error", "-deprecation -Xfatal-warnings") {
    """
      | import TestMacro._
      | test[Any] {
      |   0
      | }
    """.stripMargin
  }
}