Add proper name to tasty.Symbol

Author: nicolasstucki

compiler/src/dotty/tools/dotc/tasty/internal/TastySymbol.scala

@@ -4,6 +4,7 @@ import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.Symbols._
 
 import scala.tasty.trees
+import scala.tasty.names
 
 object TastySymbol {
 
@@ -12,23 +13,13 @@ object TastySymbol {
 
   private class Impl(sym: Symbol, ctx: Context) extends scala.tasty.Symbol { self =>
 
-    override def name: String = sym.name(ctx).toString
+    override def name: names.Name = Name(sym.name(ctx))
 
     override def owner: scala.tasty.Symbol = TastySymbol(sym.denot(ctx).owner)(ctx)
 
     override def definition: Option[trees.Definition] = None // TODO return definition if it is known
 
-    def ownersIterator: Iterator[scala.tasty.Symbol] = new Iterator[scala.tasty.Symbol] {
-      private[this] var current: scala.tasty.Symbol = self.owner
-      override def hasNext = current != scala.tasty.NoSymbol
-      override def next() = {
-        val c = current
-        current = current.owner
-        c
-      }
-    }
-
     override def toString: String =
-      s"Symbol(${ownersIterator.foldLeft(name)((acc, s) => s"${s.name}.$acc")})"
+      s"Symbol(${sym.showFullName(ctx)})"
   }
 }

library/src/scala/tasty/NoSymbol.scala

@@ -1,7 +1,9 @@
 package scala.tasty
 
+import scala.tasty.names.Name
+
 object NoSymbol extends Symbol {
-  def name: String = "NoSymbol"
+  def name: Name = new Name { override def toString = "<NoSymbol>" } // name that cannot be extracted
   def owner: Symbol = NoSymbol
   def definition: None.type = None
   override def toString: String = "NoSymbol"

library/src/scala/tasty/Symbol.scala

@@ -1,9 +1,10 @@
 package scala.tasty
 
+import scala.tasty.names.Name
 import scala.tasty.trees.Definition
 
 trait Symbol {
-  def name: String // TODO should be Name?
+  def name: Name
   def owner: Symbol
   def definition: Option[Definition]
 }

tests/pos/tasty/definitions.scala

@@ -55,6 +55,7 @@ object definitions {
 // ------ Definitions ---------------------------------
 
   trait Symbol {
+    def name: Name = ???
     def owner: Symbol = ???
     def definition: Option[Definition] = ???
   }

tests/run-with-compiler/tasty-extractors-1.check

@@ -17,16 +17,16 @@ Literal(String("abc"))
 ConstantType(String("abc"))
 
 Apply(Ident(Simple(println)), List(Literal(String("abc"))))
-SymRef(Symbol(<root>.scala.Unit), ThisType(SymRef(Symbol(<root>.scala), NoPrefix)))
+SymRef(Symbol(scala.Unit), ThisType(SymRef(Symbol(scala), NoPrefix)))
 
 Typed(Literal(Int(8)), Ident(TypeName(Simple(Int))))
-NameRef(TypeName(Simple(Int)), SymRef(Symbol(<root>.scala), ThisType(SymRef(Symbol(<root>), NoPrefix))))
+NameRef(TypeName(Simple(Int)), SymRef(Symbol(scala), ThisType(SymRef(Symbol(<root>), NoPrefix))))
 
 Typed(Literal(Byte(8)), Ident(TypeName(Simple(Byte))))
-NameRef(TypeName(Simple(Byte)), SymRef(Symbol(<root>.scala), ThisType(SymRef(Symbol(<root>), NoPrefix))))
+NameRef(TypeName(Simple(Byte)), SymRef(Symbol(scala), ThisType(SymRef(Symbol(<root>), NoPrefix))))
 
 Typed(Literal(Short(8)), Ident(TypeName(Simple(Short))))
-NameRef(TypeName(Simple(Short)), SymRef(Symbol(<root>.scala), ThisType(SymRef(Symbol(<root>), NoPrefix))))
+NameRef(TypeName(Simple(Short)), SymRef(Symbol(scala), ThisType(SymRef(Symbol(<root>), NoPrefix))))
 
 Literal(Char('a'))
 ConstantType(Char('a'))
@@ -35,89 +35,89 @@ Block(List(Literal(Int(1)), Literal(Int(2))), Literal(Int(3)))
 ConstantType(Int(3))
 
 If(Typed(Literal(Boolean(true)), Ident(TypeName(Simple(Boolean)))), Literal(Int(1)), Literal(Int(2)))
-SymRef(Symbol(<root>.scala.Int), ThisType(SymRef(Symbol(<root>.scala), NoPrefix)))
+SymRef(Symbol(scala.Int), ThisType(SymRef(Symbol(scala), NoPrefix)))
 
 Match(Literal(String("a")), List(CaseDef(Value(Literal(String("a"))), None, Block(Nil, Literal(Unit())))))
-SymRef(Symbol(<root>.scala.Unit), ThisType(SymRef(Symbol(<root>.scala), NoPrefix)))
+SymRef(Symbol(scala.Unit), ThisType(SymRef(Symbol(scala), NoPrefix)))
 
 Match(Literal(String("b")), List(CaseDef(Bind(Simple(n), Value(Ident(Simple(_)))), None, Block(Nil, Literal(Unit())))))
-SymRef(Symbol(<root>.scala.Unit), ThisType(SymRef(Symbol(<root>.scala), NoPrefix)))
+SymRef(Symbol(scala.Unit), ThisType(SymRef(Symbol(scala), NoPrefix)))
 
 Match(Literal(String("c")), List(CaseDef(Bind(Simple(n), TypeTest(Ident(TypeName(Simple(String))))), None, Block(Nil, Literal(Unit())))))
-SymRef(Symbol(<root>.scala.Unit), ThisType(SymRef(Symbol(<root>.scala), NoPrefix)))
+SymRef(Symbol(scala.Unit), ThisType(SymRef(Symbol(scala), NoPrefix)))
 
 Match(Literal(String("e")), List(CaseDef(Value(Ident(Simple(_))), None, Block(Nil, Literal(Unit())))))
-SymRef(Symbol(<root>.scala.Unit), ThisType(SymRef(Symbol(<root>.scala), NoPrefix)))
+SymRef(Symbol(scala.Unit), ThisType(SymRef(Symbol(scala), NoPrefix)))
 
 Match(Literal(String("f")), List(CaseDef(TypeTest(Ident(TypeName(Simple(String)))), None, Block(Nil, Literal(Unit())))))
-SymRef(Symbol(<root>.scala.Unit), ThisType(SymRef(Symbol(<root>.scala), NoPrefix)))
+SymRef(Symbol(scala.Unit), ThisType(SymRef(Symbol(scala), NoPrefix)))
 
 Match(Literal(String("g")), List(CaseDef(Alternative(List(TypeTest(Ident(TypeName(Simple(String)))), TypeTest(Ident(TypeName(Simple(Int)))))), None, Block(Nil, Literal(Unit())))))
-SymRef(Symbol(<root>.scala.Unit), ThisType(SymRef(Symbol(<root>.scala), NoPrefix)))
+SymRef(Symbol(scala.Unit), ThisType(SymRef(Symbol(scala), NoPrefix)))
 
 Match(Literal(String("h")), List(CaseDef(Value(Ident(Simple(_))), Some(Literal(Boolean(false))), Block(Nil, Literal(Unit())))))
-SymRef(Symbol(<root>.scala.Unit), ThisType(SymRef(Symbol(<root>.scala), NoPrefix)))
+SymRef(Symbol(scala.Unit), ThisType(SymRef(Symbol(scala), NoPrefix)))
 
 Block(List(ValDef(Simple(a), Synthetic(), Some(Literal(String("o"))), List())), Match(Literal(String("i")), List(CaseDef(Bind(Simple(a), Value(Ident(Simple(_)))), None, Block(Nil, Literal(Unit()))))))
-SymRef(Symbol(<root>.scala.Unit), ThisType(SymRef(Symbol(<root>.scala), NoPrefix)))
+SymRef(Symbol(scala.Unit), ThisType(SymRef(Symbol(scala), NoPrefix)))
 
 Match(Apply(TypeApply(Select(Ident(Simple(Option)), Simple(apply)), List(Synthetic())), List(Literal(Int(4)))), List(CaseDef(TypeTest(Synthetic()), None, Block(Nil, Typed(Ident(Simple(a)), Synthetic()))), CaseDef(Value(Ident(Simple(None))), None, Block(Nil, Literal(Int(1))))))
-NameRef(TypeName(Simple(Int)), SymRef(Symbol(<root>.scala), ThisType(SymRef(Symbol(<root>), NoPrefix))))
+NameRef(TypeName(Simple(Int)), SymRef(Symbol(scala), ThisType(SymRef(Symbol(<root>), NoPrefix))))
 
 Match(Ident(Simple(Nil)), List(CaseDef(Unapply(TypeApply(Select(Ident(Simple(List)), Simple(unapplySeq)), List(Synthetic())), Nil, List(Bind(Simple(a), Value(Ident(Simple(_)))), Bind(Simple(b), Value(Ident(Simple(_)))), Bind(Simple(c), Value(Ident(Simple(_)))))), None, Block(Nil, Literal(Unit())))))
-SymRef(Symbol(<root>.scala.Unit), ThisType(SymRef(Symbol(<root>.scala), NoPrefix)))
+SymRef(Symbol(scala.Unit), ThisType(SymRef(Symbol(scala), NoPrefix)))
 
 Try(Literal(Int(1)), List(CaseDef(Value(Ident(Simple(_))), None, Block(Nil, Literal(Unit())))), None)
-OrType(SymRef(Symbol(<root>.scala.Int), ThisType(SymRef(Symbol(<root>.scala), NoPrefix))), SymRef(Symbol(<root>.scala.Unit), ThisType(SymRef(Symbol(<root>.scala), NoPrefix))))
+OrType(SymRef(Symbol(scala.Int), ThisType(SymRef(Symbol(scala), NoPrefix))), SymRef(Symbol(scala.Unit), ThisType(SymRef(Symbol(scala), NoPrefix))))
 
 Try(Literal(Int(2)), Nil, Some(Literal(Unit())))
 ConstantType(Int(2))
 
 Try(Literal(Int(3)), List(CaseDef(Value(Ident(Simple(_))), None, Block(Nil, Literal(Unit())))), Some(Literal(Unit())))
-OrType(SymRef(Symbol(<root>.scala.Int), ThisType(SymRef(Symbol(<root>.scala), NoPrefix))), SymRef(Symbol(<root>.scala.Unit), ThisType(SymRef(Symbol(<root>.scala), NoPrefix))))
+OrType(SymRef(Symbol(scala.Int), ThisType(SymRef(Symbol(scala), NoPrefix))), SymRef(Symbol(scala.Unit), ThisType(SymRef(Symbol(scala), NoPrefix))))
 
 Apply(Select(Literal(String("a")), Simple(==)), List(Literal(String("b"))))
-SymRef(Symbol(<root>.scala.Boolean), ThisType(SymRef(Symbol(<root>.scala), NoPrefix)))
+SymRef(Symbol(scala.Boolean), ThisType(SymRef(Symbol(scala), NoPrefix)))
 
 Apply(Select(New(Ident(TypeName(Simple(Object)))), Simple(<init>)), Nil)
-SymRef(Symbol(<root>.java.lang.Object), ThisType(SymRef(Symbol(<root>.java.lang), NoPrefix)))
+SymRef(Symbol(java.lang.Object), ThisType(SymRef(Symbol(java.lang), NoPrefix)))
 
 Apply(Select(Ident(Simple(Int)), Simple(box)), List(NamedArg(Simple(x), Literal(Int(9)))))
-SymRef(Symbol(<root>.java.lang.Integer), ThisType(SymRef(Symbol(<root>.java.lang), NoPrefix)))
+SymRef(Symbol(java.lang.Integer), ThisType(SymRef(Symbol(java.lang), NoPrefix)))
 
 Apply(TypeApply(Select(Ident(Simple(Ordering)), Simple(apply)), List(Ident(TypeName(Simple(Int))))), List(Ident(Simple(Int))))
-AppliedType(SymRef(Symbol(<root>.scala.math.Ordering), ThisType(SymRef(Symbol(<root>.scala.math), NoPrefix))), List(NameRef(TypeName(Simple(Int)), SymRef(Symbol(<root>.scala), ThisType(SymRef(Symbol(<root>), NoPrefix))))))
+AppliedType(SymRef(Symbol(scala.math.Ordering), ThisType(SymRef(Symbol(scala.math), NoPrefix))), List(NameRef(TypeName(Simple(Int)), SymRef(Symbol(scala), ThisType(SymRef(Symbol(<root>), NoPrefix))))))
 
 Block(List(ValDef(Simple(a), Ident(TypeName(Simple(Int))), Some(Literal(Int(3))), List())), Literal(Unit()))
-SymRef(Symbol(<root>.scala.Unit), ThisType(SymRef(Symbol(<root>.scala), NoPrefix)))
+SymRef(Symbol(scala.Unit), ThisType(SymRef(Symbol(scala), NoPrefix)))
 
 Block(List(ValDef(Simple(b), Ident(TypeName(Simple(Int))), Some(Literal(Int(3))), List())), Literal(Unit()))
-SymRef(Symbol(<root>.scala.Unit), ThisType(SymRef(Symbol(<root>.scala), NoPrefix)))
+SymRef(Symbol(scala.Unit), ThisType(SymRef(Symbol(scala), NoPrefix)))
 
 Block(List(DefDef(Simple(f1), List(), List(), Ident(TypeName(Simple(Int))), Some(Literal(Int(3))), List())), Literal(Unit()))
-SymRef(Symbol(<root>.scala.Unit), ThisType(SymRef(Symbol(<root>.scala), NoPrefix)))
+SymRef(Symbol(scala.Unit), ThisType(SymRef(Symbol(scala), NoPrefix)))
 
 Block(List(DefDef(Simple(f2), List(), List(), Ident(TypeName(Simple(Int))), Some(Return(Literal(Int(4)))), List())), Literal(Unit()))
-SymRef(Symbol(<root>.scala.Unit), ThisType(SymRef(Symbol(<root>.scala), NoPrefix)))
+SymRef(Symbol(scala.Unit), ThisType(SymRef(Symbol(scala), NoPrefix)))
 
 Block(List(DefDef(Simple(f3), List(), List(List(ValDef(Simple(i), Ident(TypeName(Simple(Int))), None, List()))), Ident(TypeName(Simple(Int))), Some(Ident(Simple(i))), List())), Literal(Unit()))
-SymRef(Symbol(<root>.scala.Unit), ThisType(SymRef(Symbol(<root>.scala), NoPrefix)))
+SymRef(Symbol(scala.Unit), ThisType(SymRef(Symbol(scala), NoPrefix)))
 
 Block(List(DefDef(Simple(f4), List(), List(List(ValDef(Simple(i), Ident(TypeName(Simple(Int))), None, List())), List(ValDef(Simple(j), Ident(TypeName(Simple(Int))), None, List()))), Ident(TypeName(Simple(Int))), Some(Apply(Select(Ident(Simple(i)), Simple(+)), List(Ident(Simple(j))))), List())), Literal(Unit()))
-SymRef(Symbol(<root>.scala.Unit), ThisType(SymRef(Symbol(<root>.scala), NoPrefix)))
+SymRef(Symbol(scala.Unit), ThisType(SymRef(Symbol(scala), NoPrefix)))
 
 Block(List(DefDef(Simple(f5), List(), List(List(ValDef(Simple(i), Ident(TypeName(Simple(Int))), None, List()))), Ident(TypeName(Simple(Int))), Some(Ident(Simple(i))), List()), DefDef(DefaultGetter(Simple(f5), f5), List(), List(), Synthetic(), Some(Literal(Int(9))), List())), Literal(Unit()))
-SymRef(Symbol(<root>.scala.Unit), ThisType(SymRef(Symbol(<root>.scala), NoPrefix)))
+SymRef(Symbol(scala.Unit), ThisType(SymRef(Symbol(scala), NoPrefix)))
 
 Block(List(DefDef(Simple(f6), List(TypeDef(TypeName(Simple(T)), TypeBoundsTree(Synthetic(), Synthetic()), List())), List(List(ValDef(Simple(x), Ident(TypeName(Simple(T))), None, List()))), Ident(TypeName(Simple(T))), Some(Ident(Simple(x))), List())), Literal(Unit()))
-SymRef(Symbol(<root>.scala.Unit), ThisType(SymRef(Symbol(<root>.scala), NoPrefix)))
+SymRef(Symbol(scala.Unit), ThisType(SymRef(Symbol(scala), NoPrefix)))
 
 Block(List(DefDef(Simple(f7), List(TypeDef(TypeName(Simple(T)), TypeBoundsTree(Synthetic(), Synthetic()), List())), List(List(ValDef(Simple(x), Ident(TypeName(Simple(T))), None, List()))), Singleton(Ident(Simple(x))), Some(Ident(Simple(x))), List())), Literal(Unit()))
-SymRef(Symbol(<root>.scala.Unit), ThisType(SymRef(Symbol(<root>.scala), NoPrefix)))
+SymRef(Symbol(scala.Unit), ThisType(SymRef(Symbol(scala), NoPrefix)))
 
 Block(List(DefDef(Simple(f8), List(), List(List(ValDef(Simple(i), Annotated(Applied(Synthetic(), List(Ident(TypeName(Simple(Int))))), Apply(Select(New(Synthetic()), Simple(<init>)), Nil)), None, List()))), Ident(TypeName(Simple(Int))), Some(Literal(Int(9))), List())), Apply(Ident(Simple(f8)), List(Typed(Repeated(List(Literal(Int(1)), Literal(Int(2)), Literal(Int(3)))), Synthetic()))))
-NameRef(TypeName(Simple(Int)), SymRef(Symbol(<root>.scala), ThisType(SymRef(Symbol(<root>), NoPrefix))))
+NameRef(TypeName(Simple(Int)), SymRef(Symbol(scala), ThisType(SymRef(Symbol(<root>), NoPrefix))))
 
 Block(List(DefDef(Simple(f9), List(), List(List(ValDef(Simple(i), ByName(Ident(TypeName(Simple(Int)))), None, List()))), Ident(TypeName(Simple(Int))), Some(Ident(Simple(i))), List())), Literal(Unit()))
-SymRef(Symbol(<root>.scala.Unit), ThisType(SymRef(Symbol(<root>.scala), NoPrefix)))
+SymRef(Symbol(scala.Unit), ThisType(SymRef(Symbol(scala), NoPrefix)))