Tasty reflect symbols refactorings

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 {

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

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]]]
     }
   }
 

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]]
     }
 
   }

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
         }
       }

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

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"}
       }
 

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")})}

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)

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})

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 {