small update for types

Author: poechsel

compiler/src/dotty/tools/dotc/tastyreflect/TypeOrBoundsTreesOpsImpl.scala

@@ -18,6 +18,7 @@ trait TypeOrBoundsTreesOpsImpl extends scala.tasty.reflect.TypeOrBoundsTreeOps w
 
   def TypeTreeDeco(tpt: TypeTree): TypeTreeAPI = new TypeTreeAPI {
     def pos(implicit ctx: Context): Position = tpt.pos
+    def symbol(implicit ctx: Context): Symbol = tpt.symbol
     def tpe(implicit ctx: Context): Type = tpt.tpe.stripTypeVar
     def symbol(implicit ctx: Context): Symbol = tpt.symbol
   }
@@ -31,8 +32,6 @@ trait TypeOrBoundsTreesOpsImpl extends scala.tasty.reflect.TypeOrBoundsTreeOps w
 
   object TypeTree extends TypeTreeModule {
 
-    def symbol(x: TypeTree)(implicit ctx: Context): Symbol =
-      x.symbol
     object Synthetic extends SyntheticExtractor {
       def unapply(x: TypeTree)(implicit ctx: Context): Boolean = x match {
         case x @ Trees.TypeTree() => !x.tpe.isInstanceOf[Types.TypeBounds]

library/src/scala/tasty/reflect/TypeOrBoundsTreeOps.scala

@@ -28,7 +28,6 @@ trait TypeOrBoundsTreeOps extends Core {
   val TypeTree: TypeTreeModule
   abstract class TypeTreeModule {
 
-    def symbol(x: TypeTree)(implicit ctx: Context): Symbol
 
     /** TypeTree containing an inferred type */
     val Synthetic: SyntheticExtractor

semanticdb/src/dotty/semanticdb/SemanticdbConsumer.scala

@@ -83,10 +83,13 @@ class SemanticdbConsumer extends TastyConsumer {
                 else {
                   symbol match {
                     case IsPackageSymbol(symbol) => symbol.name + "/"
-                    case IsClassSymbol(symbol)   => symbol.name + "#"
                     case IsDefSymbol(symbol) =>
                       symbol.name + disimbiguate(previous_symbol + symbol.name) + "."
                     case IsValSymbol(symbol) => symbol.name + "."
+                    case IsTypeSymbol(symbol) =>
+                      symbol.name + "#"
+                    case IsClassSymbol(symbol) =>
+                      symbol.name + (if (symbol.flags.isObject) "." else "#")
                     case owner => {
                       ""
                     }
@@ -107,7 +110,6 @@ class SemanticdbConsumer extends TastyConsumer {
         val symbol_path = iterateParent(symbol)
         if (symbol_path == "" || symbol.name == "<init>") return
 
-        //println(symbol_path, symbol, range)
         occurrences =
           occurrences :+
             s.SymbolOccurrence(
@@ -136,30 +138,26 @@ class SemanticdbConsumer extends TastyConsumer {
                        range.endColumn)
       }
 
+      def typetreeSymbol(typetree: TypeTree): Unit =
+        typetree match {
+          case TypeTree.Synthetic => ()
+          case _ =>
+            addOccurence(typetree.symbol,
+                         s.SymbolOccurrence.Role.REFERENCE,
+                         range(typetree.pos, typetree.symbol.name))
+        }
+
       override def traverseTree(tree: Tree)(implicit ctx: Context): Unit = {
         //println(tree.pos.startColumn, tree.symbol.name, tree.pos.endColumn)
         tree match {
           case IsDefinition(body) => {
-
-            def typetreeSymbol(typetree: TypeTree): Unit =
-              typetree match {
-                case TypeTree.Synthetic => ()
-                case _ =>
-                  println(tree.symbol,
-                          typetree,
-                          iterateParent(TypeTree.symbol(typetree)))
-                  addOccurence(
-                    TypeTree.symbol(typetree),
-                    s.SymbolOccurrence.Role.REFERENCE,
-                    range(typetree.pos, TypeTree.symbol(typetree).name))
+            if (tree.symbol.name != "<init>") {
+              val _ = tree match {
+                case DefDef(_, _, _, typetree, _) => typetreeSymbol(typetree)
+                case ValDef(_, typetree, _)       => typetreeSymbol(typetree)
+                case _                            => ()
               }
-
-            val _ = tree match {
-              case DefDef(_, _, _, typetree, _) => typetreeSymbol(typetree)
-              case ValDef(_, typetree, _)       => typetreeSymbol(typetree)
-              case _                            => ()
             }
-
             addOccurence(tree.symbol,
                          s.SymbolOccurrence.Role.DEFINITION,
                          range(tree.symbol.pos, tree.symbol.name))
@@ -173,14 +171,20 @@ class SemanticdbConsumer extends TastyConsumer {
             super.traverseTree(tree)
           }
 
-          case Term.Ident(body) => {
+          case Term.Ident(_) => {
             //println(tree.pos.startColumn, tree.pos.endColumn)
             //println(tree.namePos.startColumn, tree.namePos.endColumn)
             addOccurence(tree.symbol,
                          s.SymbolOccurrence.Role.REFERENCE,
                          range(tree.pos, tree.symbol.name))
             super.traverseTree(tree)
           }
+          case PackageClause(_) =>
+            addOccurence(tree.symbol,
+                         s.SymbolOccurrence.Role.REFERENCE,
+                         range(tree.pos, tree.symbol.name))
+            super.traverseTree(tree)
+
           case tree =>
             super.traverseTree(tree)
         }