Merge pull request #7014 from dotty-staging/tasty-symbol-refactor

nicolasstucki · web-flow · commit 259ee051b681 · 2019-08-08T17:34:19.000+02:00
Tasty reflect symbols refactorings
diff --git a/community-build/community-projects/sourcecode b/community-build/community-projects/sourcecode
@@ -1 +1 @@
-Subproject commit 7681b10f0a47835a1a28c8b9a70a2837d236d254
+Subproject commit 30bab2fe8261cab8c68de1b8ab540a83750de733
diff --git a/library/src-bootstrapped/dotty/internal/StringContextMacro.scala b/library/src-bootstrapped/dotty/internal/StringContextMacro.scala
@@ -625,11 +625,11 @@ object StringContextMacro {
      *  nothing otherwise
      */
     def checkTypeWithArgs(argument : (Type, Int), conversionChar : Char, partIndex : Int, flags : List[(Char, Int)]) = {
-      val booleans = List(definitions.BooleanType, definitions.NullType)
-      val dates = List(definitions.LongType, typeOf[java.util.Calendar], typeOf[java.util.Date])
-      val floatingPoints = List(definitions.DoubleType, definitions.FloatType, typeOf[java.math.BigDecimal])
-      val integral = List(definitions.IntType, definitions.LongType, definitions.ShortType, definitions.ByteType, typeOf[java.math.BigInteger])
-      val character = List(definitions.CharType, definitions.ByteType, definitions.ShortType, definitions.IntType)
+      val booleans = List(defn.BooleanType, defn.NullType)
+      val dates = List(defn.LongType, typeOf[java.util.Calendar], typeOf[java.util.Date])
+      val floatingPoints = List(defn.DoubleType, defn.FloatType, typeOf[java.math.BigDecimal])
+      val integral = List(defn.IntType, defn.LongType, defn.ShortType, defn.ByteType, typeOf[java.math.BigInteger])
+      val character = List(defn.CharType, defn.ByteType, defn.ShortType, defn.IntType)
 
       val (argType, argIndex) = argument
       conversionChar match {
diff --git a/library/src-bootstrapped/scala/internal/quoted/Matcher.scala b/library/src-bootstrapped/scala/internal/quoted/Matcher.scala
@@ -104,7 +104,7 @@ object Matcher {
         case (IsTerm(scrutinee @ Typed(s, tpt1)), Typed(TypeApply(patternHole, tpt :: Nil), tpt2))
             if patternHole.symbol == internal.Definitions_InternalQuoted_patternHole &&
                s.tpe <:< tpt.tpe &&
-               tpt2.tpe.derivesFrom(definitions.RepeatedParamClass) =>
+               tpt2.tpe.derivesFrom(defn.RepeatedParamClass) =>
           matched(scrutinee.seal)
 
         // Match a scala.internal.Quoted.patternHole and return the scrutinee tree
diff --git a/library/src-bootstrapped/scala/quoted/Liftable.scala b/library/src-bootstrapped/scala/quoted/Liftable.scala
@@ -41,7 +41,7 @@ object Liftable {
     /** Lift a `Class[T]` into `'{ classOf[T] }` */
     def toExpr(x: Class[T]) = given qctx => {
       import qctx.tasty._
-      Ref(definitions.Predef_classOf).appliedToType(Type(x)).seal.asInstanceOf[Expr[Class[T]]]
+      Ref(defn.Predef_classOf).appliedToType(Type(x)).seal.asInstanceOf[Expr[Class[T]]]
     }
   }
 
diff --git a/library/src/scala/quoted/Type.scala b/library/src/scala/quoted/Type.scala
@@ -19,47 +19,47 @@ package quoted {
 
     given UnitTag as Type[Unit] given (qctx: QuoteContext) = {
       import qctx.tasty._
-      definitions.UnitType.seal.asInstanceOf[quoted.Type[Unit]]
+      defn.UnitType.seal.asInstanceOf[quoted.Type[Unit]]
     }
 
     given BooleanTag as Type[Boolean] given (qctx: QuoteContext) = {
       import qctx.tasty._
-      definitions.BooleanType.seal.asInstanceOf[quoted.Type[Boolean]]
+      defn.BooleanType.seal.asInstanceOf[quoted.Type[Boolean]]
     }
 
     given ByteTag as Type[Byte] given (qctx: QuoteContext) = {
       import qctx.tasty._
-      definitions.ByteType.seal.asInstanceOf[quoted.Type[Byte]]
+      defn.ByteType.seal.asInstanceOf[quoted.Type[Byte]]
     }
 
     given CharTag as Type[Char] given (qctx: QuoteContext) = {
       import qctx.tasty._
-      definitions.CharType.seal.asInstanceOf[quoted.Type[Char]]
+      defn.CharType.seal.asInstanceOf[quoted.Type[Char]]
     }
 
     given ShortTag as Type[Short] given (qctx: QuoteContext) = {
       import qctx.tasty._
-      definitions.ShortType.seal.asInstanceOf[quoted.Type[Short]]
+      defn.ShortType.seal.asInstanceOf[quoted.Type[Short]]
     }
 
     given IntTag as Type[Int] given (qctx: QuoteContext) = {
       import qctx.tasty._
-      definitions.IntType.seal.asInstanceOf[quoted.Type[Int]]
+      defn.IntType.seal.asInstanceOf[quoted.Type[Int]]
     }
 
     given LongTag as Type[Long] given (qctx: QuoteContext) = {
       import qctx.tasty._
-      definitions.LongType.seal.asInstanceOf[quoted.Type[Long]]
+      defn.LongType.seal.asInstanceOf[quoted.Type[Long]]
     }
 
     given FloatTag as Type[Float] given (qctx: QuoteContext) = {
       import qctx.tasty._
-      definitions.FloatType.seal.asInstanceOf[quoted.Type[Float]]
+      defn.FloatType.seal.asInstanceOf[quoted.Type[Float]]
     }
 
     given DoubleTag as Type[Double] given (qctx: QuoteContext) = {
       import qctx.tasty._
-      definitions.DoubleType.seal.asInstanceOf[quoted.Type[Double]]
+      defn.DoubleType.seal.asInstanceOf[quoted.Type[Double]]
     }
 
   }
diff --git a/library/src/scala/tasty/reflect/Printers.scala b/library/src/scala/tasty/reflect/Printers.scala
@@ -1518,7 +1518,7 @@ trait Printers
         case Type.IsTypeRef(tpe) =>
           val sym = tpe.typeSymbol
           tpe.qualifier match {
-            case Type.ThisType(Types.EmptyPackage() | Types.RootPackage()) =>
+            case Type.ThisType(tp) if tp.typeSymbol == defn.RootClass || tp.typeSymbol == defn.EmptyPackageClass =>
             case NoPrefix() =>
               if (sym.owner.flags.is(Flags.Package)) {
                 // TODO should these be in the prefix? These are at least `scala`, `java` and `scala.collection`.
@@ -1542,7 +1542,9 @@ trait Printers
 
         case Type.TermRef(prefix, name) =>
           prefix match {
-            case NoPrefix() | Type.ThisType(Types.EmptyPackage() | Types.RootPackage()) =>
+            case NoPrefix() =>
+                this += highlightTypeDef(name)
+            case Type.ThisType(tp) if tp.typeSymbol == defn.RootClass || tp.typeSymbol == defn.EmptyPackageClass =>
                 this += highlightTypeDef(name)
             case _ =>
               printTypeOrBound(prefix)
@@ -1597,7 +1599,8 @@ trait Printers
               this += highlightTypeDef(".this")
             case Type.TypeRef(prefix, name) if name.endsWith("$") =>
               prefix match {
-                case NoPrefix() | Type.ThisType(Types.EmptyPackage() | Types.RootPackage()) =>
+                case NoPrefix() =>
+                case Type.ThisType(tp) if tp.typeSymbol == defn.RootClass || tp.typeSymbol == defn.EmptyPackageClass =>
                 case _ =>
                   printTypeOrBound(prefix)
                   this += "."
@@ -1898,21 +1901,7 @@ trait Printers
 
       object ScalaPackage {
         def unapply(tpe: TypeOrBounds) given (ctx: Context): Boolean = tpe match {
-          case Type.IsTermRef(tpe) => tpe.termSymbol == definitions.ScalaPackage
-          case _ => false
-        }
-      }
-
-      object RootPackage {
-        def unapply(tpe: TypeOrBounds) given (ctx: Context): Boolean = tpe match {
-          case Type.IsTypeRef(tpe) => tpe.typeSymbol.fullName == "<root>" // TODO use Symbol.==
-          case _ => false
-        }
-      }
-
-      object EmptyPackage {
-        def unapply(tpe: TypeOrBounds) given (ctx: Context): Boolean = tpe match {
-          case Type.IsTypeRef(tpe) => tpe.typeSymbol.fullName == "<empty>"
+          case Type.IsTermRef(tpe) => tpe.termSymbol == defn.ScalaPackage
           case _ => false
         }
       }
diff --git a/library/src/scala/tasty/reflect/StandardDefinitions.scala b/library/src/scala/tasty/reflect/StandardDefinitions.scala
@@ -6,7 +6,7 @@ trait StandardDefinitions extends Core {
   /** A value containing all standard definitions in [[DefinitionsAPI]]
     *  @group Definitions
     */
-  object definitions extends StandardSymbols with StandardTypes
+  object defn extends StandardSymbols with StandardTypes
 
   /** Defines standard symbols (and types via its base trait).
     *  @group API
diff --git a/tests/run-macros/f-interpolation-1/FQuote_1.scala b/tests/run-macros/f-interpolation-1/FQuote_1.scala
@@ -47,7 +47,7 @@ object FQuote {
     val Typed(Repeated(allArgs, _), _) = args.unseal.underlyingArgument
 
     for ((arg, part) <- allArgs.zip(parts.tail)) {
-      if (part.startsWith("%d") && !(arg.tpe <:< definitions.IntType)) {
+      if (part.startsWith("%d") && !(arg.tpe <:< defn.IntType)) {
         return '{s"`${${arg.show}}` is not of type Int"}
       }
 
diff --git a/tests/run-macros/tasty-definitions-1/quoted_1.scala b/tests/run-macros/tasty-definitions-1/quoted_1.scala
@@ -14,82 +14,82 @@ object Macros {
       buff += (try x catch { case ex => ex.getClass + ": " + ex.getMessage})
     }
 
-    printout(definitions.RootPackage.name)
-    printout(definitions.ScalaPackage.name)
+    printout(defn.RootPackage.name)
+    printout(defn.ScalaPackage.name)
 
-    printout(definitions.AnyClass.name)
-    printout(definitions.AnyValClass.name)
-    printout(definitions.ObjectClass.name)
-    printout(definitions.AnyRefClass.name)
+    printout(defn.AnyClass.name)
+    printout(defn.AnyValClass.name)
+    printout(defn.ObjectClass.name)
+    printout(defn.AnyRefClass.name)
 
-    printout(definitions.NullClass.name)
-    printout(definitions.NothingClass.name)
+    printout(defn.NullClass.name)
+    printout(defn.NothingClass.name)
 
-    printout(definitions.UnitClass.name)
-    printout(definitions.ByteClass.name)
-    printout(definitions.ShortClass.name)
-    printout(definitions.CharClass.name)
-    printout(definitions.IntClass.name)
-    printout(definitions.LongClass.name)
-    printout(definitions.FloatClass.name)
-    printout(definitions.DoubleClass.name)
-    printout(definitions.BooleanClass.name)
+    printout(defn.UnitClass.name)
+    printout(defn.ByteClass.name)
+    printout(defn.ShortClass.name)
+    printout(defn.CharClass.name)
+    printout(defn.IntClass.name)
+    printout(defn.LongClass.name)
+    printout(defn.FloatClass.name)
+    printout(defn.DoubleClass.name)
+    printout(defn.BooleanClass.name)
 
-    printout(definitions.StringClass.name)
-    printout(definitions.ClassClass.name)
-    printout(definitions.ArrayClass.name)
-    printout(definitions.PredefModule.name)
+    printout(defn.StringClass.name)
+    printout(defn.ClassClass.name)
+    printout(defn.ArrayClass.name)
+    printout(defn.PredefModule.name)
 
-    printout(definitions.JavaLangPackage.name)
+    printout(defn.JavaLangPackage.name)
 
-    printout(definitions.ArrayModule.name)
+    printout(defn.ArrayModule.name)
 
-    printout(definitions.Array_apply.name)
-    printout(definitions.Array_clone.name)
-    printout(definitions.Array_length.name)
-    printout(definitions.Array_update.name)
+    printout(defn.Array_apply.name)
+    printout(defn.Array_clone.name)
+    printout(defn.Array_length.name)
+    printout(defn.Array_update.name)
 
-    printout(definitions.RepeatedParamClass.name)
+    printout(defn.RepeatedParamClass.name)
 
-    printout(definitions.OptionClass.name)
-    printout(definitions.NoneModule.name)
-    printout(definitions.SomeModule.name)
+    printout(defn.OptionClass.name)
+    printout(defn.NoneModule.name)
+    printout(defn.SomeModule.name)
 
-    printout(definitions.ProductClass.name)
+    printout(defn.ProductClass.name)
 
     for (i <- 0 to 25)
-      printout(definitions.FunctionClass(i).name)
+      printout(defn.FunctionClass(i).name)
 
     for (i <- 0 to 25)
-      printout(definitions.FunctionClass(i, isImplicit = true).name)
+      printout(defn.FunctionClass(i, isImplicit = true).name)
 
     for (i <- 1 to 25)
-      printout(definitions.FunctionClass(i, isErased = true).name)
+      printout(defn.FunctionClass(i, isErased = true).name)
 
     for (i <- 1 to 25)
-      printout(definitions.FunctionClass(i, isImplicit = true, isErased = true).name)
+      printout(defn.FunctionClass(i, isImplicit = true, isErased = true).name)
 
     for (i <- 2 to 22)
-      printout(definitions.TupleClass(i).name)
-
-    printout(definitions.ScalaPrimitiveValueClasses.map(_.name).toString)
-    printout(definitions.ScalaNumericValueClasses.map(_.name).toString)
-
-    printout(definitions.UnitType.showExtractors)
-    printout(definitions.ByteType.showExtractors)
-    printout(definitions.CharType.showExtractors)
-    printout(definitions.IntType.showExtractors)
-    printout(definitions.LongType.showExtractors)
-    printout(definitions.FloatType.showExtractors)
-    printout(definitions.DoubleType.showExtractors)
-    printout(definitions.BooleanType.showExtractors)
-    printout(definitions.AnyType.showExtractors)
-    printout(definitions.AnyValType.showExtractors)
-    printout(definitions.AnyRefType.showExtractors)
-    printout(definitions.ObjectType.showExtractors)
-    printout(definitions.NothingType.showExtractors)
-    printout(definitions.NullType.showExtractors)
-    printout(definitions.StringType.showExtractors)
+      printout(defn.TupleClass(i).name)
+
+    printout(defn.ScalaPrimitiveValueClasses.map(_.name).toString)
+    printout(defn.ScalaNumericValueClasses.map(_.name).toString)
+
+    printout(defn.UnitType.showExtractors)
+    printout(defn.ByteType.showExtractors)
+    printout(defn.CharType.showExtractors)
+    printout(defn.IntType.showExtractors)
+    printout(defn.LongType.showExtractors)
+    printout(defn.FloatType.showExtractors)
+    printout(defn.DoubleType.showExtractors)
+    printout(defn.BooleanType.showExtractors)
+    printout(defn.AnyType.showExtractors)
+    printout(defn.AnyValType.showExtractors)
+    printout(defn.AnyRefType.showExtractors)
+    printout(defn.ObjectType.showExtractors)
+    printout(defn.NothingType.showExtractors)
+    printout(defn.NullType.showExtractors)
+    printout(defn.StringType.showExtractors)
 
 
     '{println(${buff.result().mkString("\n")})}
diff --git a/tests/run-macros/tasty-location/quoted_1.scala b/tests/run-macros/tasty-location/quoted_1.scala
@@ -11,7 +11,7 @@ object Location {
     import qctx.tasty._
 
     def listOwnerNames(sym: Symbol, acc: List[String]): List[String] =
-      if (sym == definitions.RootClass || sym == definitions.EmptyPackageClass) acc
+      if (sym == defn.RootClass || sym == defn.EmptyPackageClass) acc
       else listOwnerNames(sym.owner, sym.name :: acc)
 
     val list = listOwnerNames(rootContext.owner, Nil)
diff --git a/tests/run-macros/tasty-typeof/Macro_1.scala b/tests/run-macros/tasty-typeof/Macro_1.scala
@@ -8,21 +8,21 @@ object Macros {
   private def testTypeOfImpl given (qctx: QuoteContext): Expr[Unit] = {
     import qctx.tasty._
     '{
-      assert(${(typeOf[Unit] =:= definitions.UnitType)}, "Unit")
-      assert(${(typeOf[Byte] =:= definitions.ByteType)}, "Byte")
-      assert(${(typeOf[Short] =:= definitions.ShortType)}, "Short")
-      assert(${(typeOf[Int] =:= definitions.IntType)}, "Int")
-      assert(${(typeOf[Long] =:= definitions.LongType)}, "Long")
-      assert(${(typeOf[Float] =:= definitions.FloatType)}, "Float")
-      assert(${(typeOf[Double] =:= definitions.DoubleType)}, "Double")
-      assert(${(typeOf[Char] =:= definitions.CharType)}, "Char")
-      assert(${(typeOf[String] =:= definitions.StringType)}, "String")
+      assert(${(typeOf[Unit] =:= defn.UnitType)}, "Unit")
+      assert(${(typeOf[Byte] =:= defn.ByteType)}, "Byte")
+      assert(${(typeOf[Short] =:= defn.ShortType)}, "Short")
+      assert(${(typeOf[Int] =:= defn.IntType)}, "Int")
+      assert(${(typeOf[Long] =:= defn.LongType)}, "Long")
+      assert(${(typeOf[Float] =:= defn.FloatType)}, "Float")
+      assert(${(typeOf[Double] =:= defn.DoubleType)}, "Double")
+      assert(${(typeOf[Char] =:= defn.CharType)}, "Char")
+      assert(${(typeOf[String] =:= defn.StringType)}, "String")
 
-      assert(${(typeOf[Any] =:= definitions.AnyType)}, "Any")
-      assert(${(typeOf[AnyRef] =:= definitions.AnyRefType)}, "AnyRef")
-      assert(${(typeOf[AnyVal] =:= definitions.AnyValType)}, "AnyVal")
-      assert(${(typeOf[Object] =:= definitions.ObjectType)}, "Object")
-      assert(${(typeOf[Nothing] =:= definitions.NothingType)}, "Nothing")
+      assert(${(typeOf[Any] =:= defn.AnyType)}, "Any")
+      assert(${(typeOf[AnyRef] =:= defn.AnyRefType)}, "AnyRef")
+      assert(${(typeOf[AnyVal] =:= defn.AnyValType)}, "AnyVal")
+      assert(${(typeOf[Object] =:= defn.ObjectType)}, "Object")
+      assert(${(typeOf[Nothing] =:= defn.NothingType)}, "Nothing")
 
       println(${typeOf[List[Int]].show})
       println(${typeOf[Macros].show})
diff --git a/tests/run-with-compiler-custom-args/tasty-interpreter/interpreter/TreeInterpreter.scala b/tests/run-with-compiler-custom-args/tasty-interpreter/interpreter/TreeInterpreter.scala
@@ -193,15 +193,15 @@ abstract class TreeInterpreter[R <: Reflection & Singleton](val reflect: R) {
     isIntegralPrimitive(tpe) || isFractionalPrimitive(tpe)
 
   private def isIntegralPrimitive(tpe: Type): Boolean = {
-    tpe <:< definitions.ByteType ||
-    tpe <:< definitions.CharType ||
-    tpe <:< definitions.ShortType ||
-    tpe <:< definitions.IntType ||
-    tpe <:< definitions.LongType
+    tpe <:< defn.ByteType ||
+    tpe <:< defn.CharType ||
+    tpe <:< defn.ShortType ||
+    tpe <:< defn.IntType ||
+    tpe <:< defn.LongType
   }
 
   private def isFractionalPrimitive(tpe: Type): Boolean =
-    tpe <:< definitions.FloatType || tpe <:< definitions.DoubleType
+    tpe <:< defn.FloatType || tpe <:< defn.DoubleType
 
 
   private object Call {

Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,7 @@ object Liftable {`
`41`	`41`	/** Lift a `Class[T]` into `'{ classOf[T] }` */
`42`	`42`	`def toExpr(x: Class[T]) = given qctx => {`
`43`	`43`	`import qctx.tasty._`
`44`		`- Ref(definitions.Predef_classOf).appliedToType(Type(x)).seal.asInstanceOf[Expr[Class[T]]]`
	`44`	`+ Ref(defn.Predef_classOf).appliedToType(Type(x)).seal.asInstanceOf[Expr[Class[T]]]`
`45`	`45`	`}`
`46`	`46`	`}`
`47`	`47`
Original file line number	Diff line number	Diff line change
`@@ -19,47 +19,47 @@ package quoted {`
`19`	`19`
`20`	`20`	`given UnitTag as Type[Unit] given (qctx: QuoteContext) = {`
`21`	`21`	`import qctx.tasty._`
`22`		`- definitions.UnitType.seal.asInstanceOf[quoted.Type[Unit]]`
	`22`	`+ defn.UnitType.seal.asInstanceOf[quoted.Type[Unit]]`
`23`	`23`	`}`
`24`	`24`
`25`	`25`	`given BooleanTag as Type[Boolean] given (qctx: QuoteContext) = {`
`26`	`26`	`import qctx.tasty._`
`27`		`- definitions.BooleanType.seal.asInstanceOf[quoted.Type[Boolean]]`
	`27`	`+ defn.BooleanType.seal.asInstanceOf[quoted.Type[Boolean]]`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`given ByteTag as Type[Byte] given (qctx: QuoteContext) = {`
`31`	`31`	`import qctx.tasty._`
`32`		`- definitions.ByteType.seal.asInstanceOf[quoted.Type[Byte]]`
	`32`	`+ defn.ByteType.seal.asInstanceOf[quoted.Type[Byte]]`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`given CharTag as Type[Char] given (qctx: QuoteContext) = {`
`36`	`36`	`import qctx.tasty._`
`37`		`- definitions.CharType.seal.asInstanceOf[quoted.Type[Char]]`
	`37`	`+ defn.CharType.seal.asInstanceOf[quoted.Type[Char]]`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`given ShortTag as Type[Short] given (qctx: QuoteContext) = {`
`41`	`41`	`import qctx.tasty._`
`42`		`- definitions.ShortType.seal.asInstanceOf[quoted.Type[Short]]`
	`42`	`+ defn.ShortType.seal.asInstanceOf[quoted.Type[Short]]`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`given IntTag as Type[Int] given (qctx: QuoteContext) = {`
`46`	`46`	`import qctx.tasty._`
`47`		`- definitions.IntType.seal.asInstanceOf[quoted.Type[Int]]`
	`47`	`+ defn.IntType.seal.asInstanceOf[quoted.Type[Int]]`
`48`	`48`	`}`
`49`	`49`
`50`	`50`	`given LongTag as Type[Long] given (qctx: QuoteContext) = {`
`51`	`51`	`import qctx.tasty._`
`52`		`- definitions.LongType.seal.asInstanceOf[quoted.Type[Long]]`
	`52`	`+ defn.LongType.seal.asInstanceOf[quoted.Type[Long]]`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`given FloatTag as Type[Float] given (qctx: QuoteContext) = {`
`56`	`56`	`import qctx.tasty._`
`57`		`- definitions.FloatType.seal.asInstanceOf[quoted.Type[Float]]`
	`57`	`+ defn.FloatType.seal.asInstanceOf[quoted.Type[Float]]`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`given DoubleTag as Type[Double] given (qctx: QuoteContext) = {`
`61`	`61`	`import qctx.tasty._`
`62`		`- definitions.DoubleType.seal.asInstanceOf[quoted.Type[Double]]`
	`62`	`+ defn.DoubleType.seal.asInstanceOf[quoted.Type[Double]]`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`}`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ object FQuote {`
`47`	`47`	`val Typed(Repeated(allArgs, _), _) = args.unseal.underlyingArgument`
`48`	`48`
`49`	`49`	`for ((arg, part) <- allArgs.zip(parts.tail)) {`
`50`		`- if (part.startsWith("%d") && !(arg.tpe <:< definitions.IntType)) {`
	`50`	`+ if (part.startsWith("%d") && !(arg.tpe <:< defn.IntType)) {`
`51`	`51`	return '{s"`${${arg.show}}` is not of type Int"}
`52`	`52`	`}`
`53`	`53`