Remove Reflection.Id

Id is the only instance of an untyped tree. It can be represented directly within the trees that use it and hence is redundant.

Author: nicolasstucki

compiler/src/dotty/tools/dotc/quoted/QuoteContextImpl.scala

@@ -481,15 +481,15 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext:
     object This extends ThisModule:
       def apply(cls: Symbol): This =
         withDefaultPos(tpd.This(cls.asClass))
-      def copy(original: Tree)(qual: Option[Id]): This =
-        tpd.cpy.This(original)(qual.getOrElse(untpd.EmptyTypeIdent))
-      def unapply(x: This): Option[Option[Id]] =
-        Some(x.id)
+      def copy(original: Tree)(qual: Option[String]): This =
+        tpd.cpy.This(original)(qual.map(x => untpd.Ident(x.toTypeName)).getOrElse(untpd.EmptyTypeIdent))
+      def unapply(x: This): Option[Option[String]] =
+        Some(optional(x.qual).map(_.name.toString))
     end This
 
     object ThisMethodsImpl extends ThisMethods:
       extension (self: This):
-        def id: Option[Id] = optional(self.qual)
+        def id: Option[String] = optional(self.qual).map(_.name.toString)
       end extension
     end ThisMethodsImpl
 
@@ -601,18 +601,19 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext:
     end SuperTypeTest
 
     object Super extends SuperModule:
-      def apply(qual: Term, mix: Option[Id]): Super =
-        withDefaultPos(tpd.Super(qual, mix.getOrElse(untpd.EmptyTypeIdent), dotc.core.Symbols.NoSymbol))
-      def copy(original: Tree)(qual: Term, mix: Option[Id]): Super =
-        tpd.cpy.Super(original)(qual, mix.getOrElse(untpd.EmptyTypeIdent))
-      def unapply(x: Super): Option[(Term, Option[Id])] =
+      def apply(qual: Term, mix: Option[String]): Super =
+        withDefaultPos(tpd.Super(qual, mix.map(x => untpd.Ident(x.toTypeName)).getOrElse(untpd.EmptyTypeIdent), dotc.core.Symbols.NoSymbol))
+      def copy(original: Tree)(qual: Term, mix: Option[String]): Super =
+        tpd.cpy.Super(original)(qual, mix.map(x => untpd.Ident(x.toTypeName)).getOrElse(untpd.EmptyTypeIdent))
+      def unapply(x: Super): Option[(Term, Option[String])] =
         Some((x.qualifier, x.id))
     end Super
 
     object SuperMethodsImpl extends SuperMethods:
       extension (self: Super):
         def qualifier: Term = self.qual
-        def id: Option[Id] = optional(self.mix)
+        def id: Option[String] = optional(self.mix).map(_.name.toString)
+        def idPos: Position = self.mix.sourcePos
       end extension
     end SuperMethodsImpl
 
@@ -1510,13 +1511,14 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext:
     end SimpleSelectorTypeTest
 
     object SimpleSelector extends SimpleSelectorModule:
-      def unapply(x: SimpleSelector): Option[Id] = Some(x.selection)
+      def unapply(x: SimpleSelector): Option[String] = Some(x.name.toString)
     end SimpleSelector
 
 
     object SimpleSelectorMethodsImpl extends SimpleSelectorMethods:
       extension (self: SimpleSelector):
-        def selection: Id = self.imported
+        def name: String = self.imported.name.toString
+        def namePos: Position = self.imported.sourcePos
       end extension
     end SimpleSelectorMethodsImpl
 
@@ -1530,13 +1532,15 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext:
     end RenameSelectorTypeTest
 
     object RenameSelector extends RenameSelectorModule:
-      def unapply(x: RenameSelector): Option[(Id, Id)] = Some((x.from, x.to))
+      def unapply(x: RenameSelector): Option[(String, String)] = Some((x.fromName, x.toName))
     end RenameSelector
 
     object RenameSelectorMethodsImpl extends RenameSelectorMethods:
       extension (self: RenameSelector):
-        def from: Id = self.imported
-        def to: Id = self.renamed.asInstanceOf[untpd.Ident]
+        def fromName: String = self.imported.name.toString
+        def fromPos: Position = self.imported.sourcePos
+        def toName: String = self.renamed.asInstanceOf[untpd.Ident].name.toString
+        def toPos: Position = self.renamed.asInstanceOf[untpd.Ident].sourcePos
       end extension
     end RenameSelectorMethodsImpl
 
@@ -1554,12 +1558,13 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext:
     end OmitSelectorTypeTest
 
     object OmitSelector extends OmitSelectorModule:
-      def unapply(x: OmitSelector): Option[Id] = Some(x.omitted)
+      def unapply(x: OmitSelector): Option[String] = Some(x.imported.name.toString)
     end OmitSelector
 
     object OmitSelectorMethodsImpl extends OmitSelectorMethods:
       extension (self: OmitSelector):
-        def omitted: Id = self.imported
+        def name: String = self.imported.toString
+        def namePos: Position = self.imported.sourcePos
       end extension
     end OmitSelectorMethodsImpl
 
@@ -2106,19 +2111,6 @@ class QuoteContextImpl private (ctx: Context) extends QuoteContext:
       end extension
     end ConstantMethodsImpl
 
-    type Id = untpd.Ident
-
-    object Id extends IdModule:
-      def unapply(id: Id): Option[String] = Some(id.name.toString)
-    end Id
-
-    object IdMethodsImpl extends IdMethods:
-      extension (self: Id):
-        def pos: Position = self.sourcePos
-        def name: String = self.name.toString
-      end extension
-    end IdMethodsImpl
-
     type ImplicitSearchResult = Tree
 
     def searchImplicit(tpe: Type): ImplicitSearchResult =

library/src/scala/tasty/Reflection.scala

@@ -586,21 +586,21 @@ trait Reflection { reflection =>
 
   trait ThisModule { this: This.type =>
 
-    /** Create a `this[<id: Id]>` */
+    /** Create a `this[<id: String]>` */
     def apply(cls: Symbol): This
 
-    def copy(original: Tree)(qual: Option[Id]): This
+    def copy(original: Tree)(qual: Option[String]): This
 
-    /** Matches `this[<id: Option[Id]>` */
-    def unapply(x: This): Option[Option[Id]]
+    /** Matches `this[<id: Option[String]>` */
+    def unapply(x: This): Option[Option[String]]
   }
 
   given ThisMethods as ThisMethods = ThisMethodsImpl
   protected val ThisMethodsImpl: ThisMethods
 
   trait ThisMethods:
     extension (self: This):
-      def id: Option[Id]
+      def id: Option[String]
     end extension
   end ThisMethods
 
@@ -735,12 +735,12 @@ trait Reflection { reflection =>
   trait SuperModule { this: Super.type =>
 
     /** Creates a `<qualifier: Term>.super[<id: Option[Id]>` */
-    def apply(qual: Term, mix: Option[Id]): Super
+    def apply(qual: Term, mix: Option[String]): Super
 
-    def copy(original: Tree)(qual: Term, mix: Option[Id]): Super
+    def copy(original: Tree)(qual: Term, mix: Option[String]): Super
 
     /** Matches a `<qualifier: Term>.super[<id: Option[Id]>` */
-    def unapply(x: Super): Option[(Term, Option[Id])]
+    def unapply(x: Super): Option[(Term, Option[String])]
   }
 
   given SuperMethods as SuperMethods = SuperMethodsImpl
@@ -749,7 +749,8 @@ trait Reflection { reflection =>
   trait SuperMethods:
     extension (self: Super):
       def qualifier: Term
-      def id: Option[Id]
+      def id: Option[String]
+      def idPos: Position
     end extension
   end SuperMethods
 
@@ -1668,7 +1669,7 @@ trait Reflection { reflection =>
   val SimpleSelector: SimpleSelectorModule
 
   trait SimpleSelectorModule { this: SimpleSelector.type =>
-    def unapply(x: SimpleSelector): Option[Id]
+    def unapply(x: SimpleSelector): Option[String]
   }
 
   /** Simple import selector: `.bar` in `import foo.bar` */
@@ -1679,7 +1680,8 @@ trait Reflection { reflection =>
 
   trait SimpleSelectorMethods:
     extension (self: SimpleSelector):
-      def selection: Id
+      def name: String
+      def namePos: Position
     end extension
   end SimpleSelectorMethods
 
@@ -1692,7 +1694,7 @@ trait Reflection { reflection =>
   val RenameSelector: RenameSelectorModule
 
   trait RenameSelectorModule { this: RenameSelector.type =>
-    def unapply(x: RenameSelector): Option[(Id, Id)]
+    def unapply(x: RenameSelector): Option[(String, String)]
   }
 
   /** Omit import selector: `.{bar => _}` in `import foo.{bar => _}` */
@@ -1703,8 +1705,10 @@ trait Reflection { reflection =>
 
   trait RenameSelectorMethods:
     extension (self: RenameSelector):
-      def from: Id
-      def to: Id
+      def fromName: String
+      def fromPos: Position
+      def toName: String
+      def toPos: Position
     end extension
   end RenameSelectorMethods
 
@@ -1714,15 +1718,16 @@ trait Reflection { reflection =>
   val OmitSelector: OmitSelectorModule
 
   trait OmitSelectorModule { this: OmitSelector.type =>
-    def unapply(x: OmitSelector): Option[Id]
+    def unapply(x: OmitSelector): Option[String]
   }
 
   given OmitSelectorMethods as OmitSelectorMethods = OmitSelectorMethodsImpl
   protected val OmitSelectorMethodsImpl: OmitSelectorMethods
 
   trait OmitSelectorMethods:
     extension (self: OmitSelector):
-      def omitted: Id
+      def name: String
+      def namePos: Position
   end OmitSelectorMethods
 
   ///////////////
@@ -2377,34 +2382,6 @@ trait Reflection { reflection =>
     end extension
   }
 
-  /////////
-  // IDs //
-  /////////
-
-  // TODO: remove Id. Add use name and pos directly on APIs that use it.
-
-  /** Untyped identifier */
-  type Id <: AnyRef
-
-  val Id: IdModule
-
-  trait IdModule { this: Id.type =>
-    def unapply(id: Id): Option[String]
-  }
-
-  given IdMethods as IdMethods = IdMethodsImpl
-  protected val IdMethodsImpl: IdMethods
-
-  trait IdMethods {
-    extension (self: Id):
-      /** Position in the source code */
-      def pos: Position
-
-      /** Name of the identifier */
-      def name: String
-    end extension
-  }
-
   /////////////////////
   // IMPLICIT SEARCH //
   /////////////////////

library/src/scala/tasty/reflect/ExtractorsPrinter.scala

@@ -227,11 +227,6 @@ class ExtractorsPrinter[R <: Reflection & Singleton](val tasty: R) extends Print
         this += "NoPrefix()"
     }
 
-    def visitId(x: Id): Buffer = {
-      val Id(name) = x
-      this += "Id(\"" += name += "\")"
-    }
-
     def visitSignature(sig: Signature): Buffer = {
       val Signature(params, res) = sig
       this += "Signature(" ++= params.map(_.toString) += ", " += res += ")"
@@ -263,6 +258,10 @@ class ExtractorsPrinter[R <: Reflection & Singleton](val tasty: R) extends Print
 
     def ++=(xs: List[String]): Buffer = visitList[String](xs, +=)
 
+    private implicit class StringOps(buff: Buffer) {
+      def +=(x: Option[String]): Buffer = { visitOption(x, y => buff += "\"" += y += "\""); buff }
+    }
+
     private implicit class TreeOps(buff: Buffer) {
       def +=(x: Tree): Buffer = { visitTree(x); buff }
       def +=(x: Option[Tree]): Buffer = { visitOption(x, visitTree); buff }
@@ -280,11 +279,6 @@ class ExtractorsPrinter[R <: Reflection & Singleton](val tasty: R) extends Print
       def ++=(x: List[Type]): Buffer = { visitList(x, visitType); buff }
     }
 
-    private implicit class IdOps(buff: Buffer) {
-      def +=(x: Id): Buffer = { visitId(x); buff }
-      def +=(x: Option[Id]): Buffer = { visitOption(x, visitId); buff }
-    }
-
     private implicit class SignatureOps(buff: Buffer) {
       def +=(x: Option[Signature]): Buffer = { visitOption(x, visitSignature); buff }
     }

library/src/scala/tasty/reflect/SourceCodePrinter.scala

@@ -340,8 +340,8 @@ class SourceCodePrinter[R <: Reflection & Singleton](val tasty: R)(syntaxHighlig
 
       case This(id) =>
         id match {
-          case Some(x) =>
-            this += x.name.stripSuffix("$") += "."
+          case Some(name) =>
+            this += name.stripSuffix("$") += "."
           case None =>
         }
         this += "this"
@@ -417,12 +417,12 @@ class SourceCodePrinter[R <: Reflection & Singleton](val tasty: R)(syntaxHighlig
 
       case Super(qual, idOpt) =>
         qual match {
-          case This(Some(Id(name))) => this += name += "."
+          case This(Some(name)) => this += name += "."
           case This(None) =>
         }
         this += "super"
         for (id <- idOpt)
-          inSquare(this += id.name)
+          inSquare(this += id)
         this
 
       case Typed(term, tpt) =>
@@ -1223,9 +1223,9 @@ class SourceCodePrinter[R <: Reflection & Singleton](val tasty: R)(syntaxHighlig
     }
 
     def printImportSelector(sel: ImportSelector): Buffer = sel match {
-      case SimpleSelector(Id(name)) => this += name
-      case OmitSelector(Id(name)) => this += name += " => _"
-      case RenameSelector(Id(name), Id(newName)) => this += name += " => " += newName
+      case SimpleSelector(name) => this += name
+      case OmitSelector(name) => this += name += " => _"
+      case RenameSelector(name, newName) => this += name += " => " += newName
     }
 
     def printDefinitionName(sym: Definition): Buffer = sym match {

tests/run-macros/tasty-extractors-2.check

@@ -70,7 +70,7 @@ TypeRef(ThisType(TypeRef(NoPrefix(), "scala")), "Unit")
 Inlined(None, Nil, Block(List(ClassDef("Foo6", DefDef("<init>", Nil, List(List(ValDef("a", TypeIdent("Int"), None)), List(ValDef("b", Singleton(Ident("a")), None))), Inferred(), None), List(Apply(Select(New(Inferred()), "<init>"), Nil)), Nil, None, List(ValDef("a", Inferred(), None), ValDef("b", Inferred(), None)))), Literal(Constant(()))))
 TypeRef(ThisType(TypeRef(NoPrefix(), "scala")), "Unit")
 
-Inlined(None, Nil, Block(List(ClassDef("Foo7", DefDef("<init>", Nil, List(List(ValDef("a", TypeIdent("Int"), None))), Inferred(), None), List(Apply(Select(New(Inferred()), "<init>"), Nil)), Nil, None, List(ValDef("a", Inferred(), None), DefDef("<init>", Nil, List(Nil), Inferred(), Some(Block(List(Apply(Select(This(Some(Id("Foo7"))), "<init>"), List(Literal(Constant(6))))), Literal(Constant(())))))))), Literal(Constant(()))))
+Inlined(None, Nil, Block(List(ClassDef("Foo7", DefDef("<init>", Nil, List(List(ValDef("a", TypeIdent("Int"), None))), Inferred(), None), List(Apply(Select(New(Inferred()), "<init>"), Nil)), Nil, None, List(ValDef("a", Inferred(), None), DefDef("<init>", Nil, List(Nil), Inferred(), Some(Block(List(Apply(Select(This(Some("Foo7")), "<init>"), List(Literal(Constant(6))))), Literal(Constant(())))))))), Literal(Constant(()))))
 TypeRef(ThisType(TypeRef(NoPrefix(), "scala")), "Unit")
 
 Inlined(None, Nil, Block(List(ClassDef("Foo8", DefDef("<init>", Nil, List(Nil), Inferred(), None), List(Apply(Select(New(Inferred()), "<init>"), Nil)), Nil, None, List(Apply(Ident("println"), List(Literal(Constant(0))))))), Literal(Constant(()))))