Updated dotty macro implementation code for dotty 20190401 build.

Author: cheeseng

project/scalatest.scala

@@ -2133,9 +2133,9 @@ object ScalatestBuild {
       name.value)
 
   import dotty.tools.sbtplugin.DottyPlugin.autoImport._
-  // List of available night build at https://repo1.maven.org/maven2/ch/epfl/lamp/dotty-compiler_0.13/
+  // List of available night build at https://repo1.maven.org/maven2/ch/epfl/lamp/dotty-compiler_0.14/
   //lazy val dottyVersion = dottyLatestNightlyBuild.get
-  lazy val dottyVersion = "0.14.0-bin-20190331-c059b64-NIGHTLY"
+  lazy val dottyVersion = "0.14.0-bin-20190401-f62e286-NIGHTLY"
   lazy val dottySettings = List(
     scalaVersion := dottyVersion,
     libraryDependencies := libraryDependencies.value.map(_.withDottyCompat(scalaVersion.value)),

scalactic.dotty/src/main/scala/org/scalactic/BooleanMacro.scala

@@ -30,10 +30,10 @@ object BooleanMacro {
       Type.IsMethodType.unapply(tp).flatMap(tp => if tp.isImplicit then Some(true) else None).nonEmpty
 
     condition.unseal.underlyingArgument match {
-      case Term.Apply(Term.Select(Term.Apply(qual, lhs :: Nil), op @ ("===" | "!==")), rhs :: Nil) =>
+      case Apply(Select(Apply(qual, lhs :: Nil), op @ ("===" | "!==")), rhs :: Nil) =>
         let(lhs) { left =>
           let(rhs) { right =>
-            let(Term.Select.overloaded(Term.Apply(qual, left :: Nil), op, Nil, right :: Nil)) { result =>
+            let(Select.overloaded(Apply(qual, left :: Nil), op, Nil, right :: Nil)) { result =>
               val l = left.seal[Any]
               val r = right.seal[Any]
               val b = result.seal[Boolean]
@@ -42,7 +42,7 @@ object BooleanMacro {
             }
           }
         }.seal[Bool]
-      case Term.Apply(sel @ Term.Select(lhs, op), rhs :: Nil) =>
+      case Apply(sel @ Select(lhs, op), rhs :: Nil) =>
         op match {
           case "||" =>
             val left = parse(lhs.seal[Boolean], prettifier)
@@ -67,7 +67,7 @@ object BooleanMacro {
               case _ =>
                 let(lhs) { left =>
                   let(rhs) { right =>
-                    val app = Term.Select.overloaded(left, op, Nil, right :: Nil)
+                    val app = Select.overloaded(left, op, Nil, right :: Nil)
                     assert(app.symbol == sel.symbol, app.symbol.fullName -> sel.symbol.fullName)
                     let(app) { result =>
                       val l = left.seal[Any]
@@ -80,11 +80,11 @@ object BooleanMacro {
                 }.seal[Bool]
             }
         }
-      case Term.Apply(f @ Term.Apply(Term.Select(Term.Apply(qual, lhs :: Nil), op @ ("===" | "!==")), rhs :: Nil), implicits)
+      case Apply(f @ Apply(Select(Apply(qual, lhs :: Nil), op @ ("===" | "!==")), rhs :: Nil), implicits)
       if isImplicitMethodType(f.tpe) =>
         let(lhs) { left =>
           let(rhs) { right =>
-            let(Term.Apply(Term.Select.overloaded(Term.Apply(qual, left :: Nil), op, Nil, right :: Nil), implicits)) { result =>
+            let(Apply(Select.overloaded(Apply(qual, left :: Nil), op, Nil, right :: Nil), implicits)) { result =>
               val l = left.seal[Any]
               val r = right.seal[Any]
               val b = result.seal[Boolean]
@@ -93,10 +93,10 @@ object BooleanMacro {
             }
           }
         }.seal[Bool]
-      case Term.Select(left, "unary_!") =>
+      case Select(left, "unary_!") =>
         val receiver = parse(left.seal[Boolean], prettifier)
         '{ !($receiver) }
-      case Term.Literal(_) =>
+      case Literal(_) =>
         '{ Bool.simpleMacroBool($condition, "", $prettifier) }
       case _ =>
         defaultCase

scalactic.dotty/src/main/scala/org/scalactic/Requirements.scala

@@ -263,7 +263,6 @@ object RequirementsMacro {
    */
   def requireNonNull(arguments: Expr[Seq[Any]], prettifier: Expr[Prettifier], pos: Expr[source.Position])(implicit reflect: Reflection): Expr[Unit] = {
     import reflect._
-    import Term._
     import quoted.Toolbox.Default._
 
     def liftSeq(args: Seq[Expr[String]]): Expr[Seq[String]] = args match {

scalactic.dotty/src/main/scala/org/scalactic/anyvals/CompileTimeAssertions.scala

@@ -205,7 +205,7 @@ trait CompileTimeAssertions {
     import refl._
 
     value.unseal.underlyingArgument match {
-      case Term.Literal(intConst) =>
+      case Literal(intConst) =>
         val literalValue = intConst.value.toString.toInt
         if (!isValid(literalValue))
           throw new TastyTypecheckError(notValidMsg)
@@ -240,7 +240,7 @@ trait CompileTimeAssertions {
     import refl._
 
     value.unseal.underlyingArgument match {
-      case Term.Literal(longConst) =>
+      case Literal(longConst) =>
         val literalValue = longConst.value.toString.toLong
         if (!isValid(literalValue))
           throw new TastyTypecheckError(notValidMsg)
@@ -275,7 +275,7 @@ trait CompileTimeAssertions {
     import refl._
 
     value.unseal.underlyingArgument match {
-      case Term.Literal(floatConst) =>
+      case Literal(floatConst) =>
         val literalValue = floatConst.value.toString.toFloat
         if (!isValid(literalValue))
           throw new TastyTypecheckError(notValidMsg)
@@ -310,7 +310,7 @@ trait CompileTimeAssertions {
     import refl._
 
     value.unseal.underlyingArgument match {
-      case Term.Literal(doubleConst) =>
+      case Literal(doubleConst) =>
         val literalValue = doubleConst.value.toString.toDouble
         if (!isValid(literalValue))
           throw new TastyTypecheckError(notValidMsg)
@@ -345,7 +345,7 @@ trait CompileTimeAssertions {
     import refl._
 
     value.unseal.underlyingArgument match {
-      case Term.Literal(stringConst) =>
+      case Literal(stringConst) =>
         val literalValue = stringConst.value.toString
         if (!isValid(literalValue))
           throw new TastyTypecheckError(notValidMsg)
@@ -380,7 +380,7 @@ trait CompileTimeAssertions {
     import refl._
 
     value.unseal.underlyingArgument match {
-      case Term.Literal(charConst) =>
+      case Literal(charConst) =>
         val literalValue = charConst.value.toString.head
         if (!isValid(literalValue))
           throw new TastyTypecheckError(notValidMsg)

scalactic.dotty/src/main/scala/org/scalactic/anyvals/RegexStringMacro.scala

@@ -48,7 +48,7 @@ private[scalactic] object RegexStringMacro {
 
     val notValidExceptionMsg: String = {
       value.unseal match {
-          case Term.Literal(stringConst) =>
+          case Literal(stringConst) =>
             checkIsValid(stringConst.value.toString)._2
           case _ =>
             ""

scalatest.dotty/src/main/scala/org/scalatest/CompileMacro.scala

@@ -164,7 +164,6 @@ object CompileMacro {
   // check that a code snippet does not compile
   def assertNotCompileImpl[T](self: Expr[T], compileWord: Expr[CompileWord], pos: Expr[source.Position])(shouldOrMust: String)(implicit refl: Reflection): Expr[Assertion] = {
     import refl._
-    import Term._
     import Constant._
 
     // parse and type check a code snippet, generate code to throw TestFailedException if both parse and type check succeeded
@@ -216,7 +215,6 @@ object CompileMacro {
   // check that a code snippet does not compile
   def assertNotTypeCheckImpl(self: Expr[Matchers#AnyShouldWrapper[_]], typeCheckWord: Expr[TypeCheckWord], pos: Expr[source.Position])(shouldOrMust: String)(implicit refl: Reflection): Expr[Assertion] = {
     import refl._
-    import Term._
     import Constant._
 
     // parse and type check a code snippet, generate code to throw TestFailedException if both parse and type check succeeded
@@ -270,7 +268,6 @@ object CompileMacro {
   // check that a code snippet compiles
   def assertCompileImpl[T](self: Expr[T], compileWord: Expr[CompileWord], pos: Expr[source.Position])(shouldOrMust: String)(implicit refl: Reflection): Expr[Assertion] = {
     import refl._
-    import Term._
     import Constant._
 
     // parse and type check a code snippet, generate code to throw TestFailedException if both parse and type check succeeded

scalatest.dotty/src/main/scala/org/scalatest/DiagrammedAssertionsMacro.scala

@@ -31,7 +31,6 @@ private[scalatest] object DiagrammedAssertionsMacro {
     prettifier: Expr[Prettifier],
     pos: Expr[source.Position])(implicit refl: Reflection): Expr[Assertion] = {
     import refl._
-    import Term._
     import quoted.Toolbox.Default._
 
     val startLine = refl.rootPosition.startLine // Get the expression first line number

scalatest.dotty/src/main/scala/org/scalatest/DiagrammedExprMacro.scala

@@ -39,7 +39,6 @@ object DiagrammedExprMacro {
   def parse[T:Type](expr: Expr[T])(implicit refl: Reflection): Expr[DiagrammedExpr[T]] = {
     import refl._
     import quoted.Toolbox.Default._
-    import Term._
 
     def isXmlSugar(apply: Apply): Boolean = apply.tpe <:< typeOf[scala.xml.Elem]
     def isJavaStatic(tree: Tree): Boolean = tree.symbol.flags.is(Flags.Static)
@@ -63,13 +62,12 @@ object DiagrammedExprMacro {
   def applyExpr[T:Type](expr: Expr[T])(implicit refl: Reflection): Expr[DiagrammedExpr[T]] = {
     import refl._
     import quoted.Toolbox.Default._
-    import Term._
 
     def apply(l: Expr[_], name: String, r: List[Expr[_]]): Expr[T] =
-      Term.Select.overloaded(l.unseal, name, Nil, r.map(_.unseal)).seal[T]
+      Select.overloaded(l.unseal, name, Nil, r.map(_.unseal)).seal[T]
 
     expr.unseal.underlyingArgument match {
-      case Term.Apply(Term.Select(lhs, op), rhs :: Nil) =>
+      case Apply(Select(lhs, op), rhs :: Nil) =>
         op match {
           case "||" | "|" =>
             val left = parse(lhs.seal[T & Boolean])
@@ -99,7 +97,7 @@ object DiagrammedExprMacro {
               DiagrammedExpr.applyExpr(l, r :: Nil, res, ${ getAnchor(expr) })
             }
         }
-      case Term.Apply(Term.Select(lhs, op), args) =>
+      case Apply(Select(lhs, op), args) =>
         val left = parse(lhs.seal[Any])
         val rights = args.map(arg => parse(arg.seal[Any]))
 
@@ -117,7 +115,6 @@ object DiagrammedExprMacro {
   def selectExpr[T:Type](expr: Expr[T])(implicit refl: Reflection): Expr[DiagrammedExpr[T]] = {
     import refl._
     import quoted.Toolbox.Default._
-    import Term._
 
     def selectField(o: Expr[_], name: String): Expr[T] = ???
 

scalatest.dotty/src/main/scala/org/scalatest/matchers/TypeMatcherMacro.scala

@@ -29,8 +29,6 @@ private[scalatest] object TypeMatcherMacro {
 //   // Check that no type parameter is specified, if any does, give a friendly compiler warning.
   def checkTypeParameter(refl: Reflection)(tree: refl.Term, methodName: String): Unit = {
     import refl._
-    import Term._
-    import TypeTree._
     import quoted.Toolbox.Default._
 
     // TODO#Macros: Select lack unapply