Minimum Singature information for Semanticdb

Author: tanishiking

compiler/src/dotty/tools/dotc/semanticdb/ConstantOps.scala

@@ -0,0 +1,27 @@
+package dotty.tools
+package dotc
+package semanticdb
+
+import dotty.tools.dotc.{semanticdb => s}
+
+import core.Contexts.Context
+import core.Constants._
+
+object ConstantOps:
+  extension (const: Constant)
+    def toSemanticConst(using Context): s.Constant = const.tag match {
+      case UnitTag => s.UnitConstant()
+      case BooleanTag => s.BooleanConstant(const.booleanValue)
+      case ByteTag => s.ByteConstant(const.byteValue)
+      case ShortTag => s.ShortConstant(const.shortValue)
+      case CharTag => s.CharConstant(const.charValue)
+      case IntTag => s.IntConstant(const.intValue)
+      case LongTag => s.LongConstant(const.longValue)
+      case FloatTag => s.FloatConstant(const.floatValue)
+      case DoubleTag => s.DoubleConstant(const.doubleValue)
+      case StringTag => s.StringConstant(const.stringValue)
+      case NullTag => s.NullConstant()
+      // ConstantType(_: Type, ClazzTag) should be converted as it's type
+      // NoTag => it shouldn't happen
+      case _ => throw new Error(s"Constant ${const} can't be converted to Semanticdb Constant.")
+    }

compiler/src/dotty/tools/dotc/semanticdb/ExtractSemanticDB.scala

@@ -22,6 +22,8 @@ import scala.collection.mutable
 import scala.annotation.{ threadUnsafe => tu, tailrec }
 import scala.PartialFunction.condOpt
 
+import SemanticSymbolBuilder._
+import SymbolInformationOps._
 
 /** Extract symbol references and uses to semanticdb files.
  *  See https://scalameta.org/docs/semanticdb/specification.html#symbol-1
@@ -49,18 +51,9 @@ class ExtractSemanticDB extends Phase:
   /** Extractor of symbol occurrences from trees */
   class Extractor extends TreeTraverser:
 
-    private var nextLocalIdx: Int = 0
-
-    /** The index of a local symbol */
-    private val locals = mutable.HashMap[Symbol, Int]()
-
     /** The bodies of synthetic locals */
     private val localBodies = mutable.HashMap[Symbol, Tree]()
 
-    /** The local symbol(s) starting at given offset */
-    private val symsAtOffset = new mutable.HashMap[Int, Set[Symbol]]():
-      override def default(key: Int) = Set[Symbol]()
-
     /** The extracted symbol occurrences */
     val occurrences = new mutable.ListBuffer[SymbolOccurrence]()
 
@@ -142,12 +135,12 @@ class ExtractSemanticDB extends Phase:
           if !tree.symbol.isAllOf(ModuleValCreationFlags) then
             if !excludeDef(tree.symbol)
             && tree.span.hasLength then
-              registerDefinition(tree.symbol, tree.nameSpan, symbolKinds(tree), tree.source)
+              registerDefinition(tree.symbol, tree.nameSpan, tree.symbolKinds, tree.source)
               val privateWithin = tree.symbol.privateWithin
               if privateWithin.exists then
                 registerUseGuarded(None, privateWithin, spanOfSymbol(privateWithin, tree.span, tree.source), tree.source)
             else if !excludeSymbol(tree.symbol) then
-              registerSymbol(tree.symbol, symbolName(tree.symbol), symbolKinds(tree))
+              registerSymbol(tree.symbol, tree.symbolKinds)
             tree match
             case tree: ValDef
             if tree.symbol.isAllOf(EnumValue) =>
@@ -248,14 +241,6 @@ class ExtractSemanticDB extends Phase:
 
     end traverse
 
-    private def funParamSymbol(funSym: Symbol)(using Context): Name => String =
-      if funSym.isGlobal then
-        val funSymbol = symbolName(funSym)
-        name => s"$funSymbol($name)"
-      else
-        name => locals.keys.find(local => local.isTerm && local.owner == funSym && local.name == name)
-                      .fold("<?>")(Symbols.LocalPrefix + _)
-
     private object PatternValDef:
 
       def unapply(tree: ValDef)(using Context): Option[(Tree, Tree)] = tree.rhs match
@@ -289,185 +274,24 @@ class ExtractSemanticDB extends Phase:
 
     end PatternValDef
 
-    /** Add semanticdb name of the given symbol to string builder */
-    private def addSymName(b: StringBuilder, sym: Symbol)(using Context): Unit =
-
-      def addName(name: Name) =
-        val str = name.toString.unescapeUnicode
-        if str.isJavaIdent then b append str
-        else b append '`' append str append '`'
-
-      def addOwner(owner: Symbol): Unit =
-        if !owner.isRoot then addSymName(b, owner)
-
-      def addOverloadIdx(sym: Symbol): Unit =
-        val decls =
-          val decls0 = sym.owner.info.decls.lookupAll(sym.name)
-          if sym.owner.isAllOf(JavaModule) then
-            decls0 ++ sym.owner.companionClass.info.decls.lookupAll(sym.name)
-          else
-            decls0
-        end decls
-        val alts = decls.filter(_.isOneOf(Method | Mutable)).toList.reverse
-        def find(filter: Symbol => Boolean) = alts match
-          case notSym :: rest if !filter(notSym) =>
-            val idx = rest.indexWhere(filter).ensuring(_ >= 0)
-            b.append('+').append(idx + 1)
-          case _ =>
-        end find
-        val sig = sym.signature
-        find(_.signature == sig)
-
-      def addDescriptor(sym: Symbol): Unit =
-        if sym.is(ModuleClass) then
-          addDescriptor(sym.sourceModule)
-        else if sym.is(TypeParam) then
-          b.append('['); addName(sym.name); b.append(']')
-        else if sym.is(Param) then
-          b.append('('); addName(sym.name); b.append(')')
-        else if sym.isRoot then
-          b.append(Symbols.RootPackage)
-        else if sym.isEmptyPackage then
-          b.append(Symbols.EmptyPackage)
-        else if (sym.isScala2PackageObject) then
-          b.append(Symbols.PackageObjectDescriptor)
-        else
-          addName(sym.name)
-          if sym.is(Package) then b.append('/')
-          else if sym.isType || sym.isAllOf(JavaModule) then b.append('#')
-          else if sym.isOneOf(Method | Mutable)
-          && (!sym.is(StableRealizable) || sym.isConstructor) then
-            b.append('('); addOverloadIdx(sym); b.append(").")
-          else b.append('.')
-
-      /** The index of local symbol `sym`. Symbols with the same name and
-       *  the same starting position have the same index.
-       */
-      def localIdx(sym: Symbol)(using Context): Int =
-        val startPos =
-          assert(sym.span.exists, s"$sym should have a span")
-          sym.span.start
-        @tailrec
-        def computeLocalIdx(sym: Symbol): Int = locals get sym match
-          case Some(idx) => idx
-          case None      => symsAtOffset(startPos).find(_.name == sym.name) match
-            case Some(other) => computeLocalIdx(other)
-            case None =>
-              val idx = nextLocalIdx
-              nextLocalIdx += 1
-              locals(sym) = idx
-              symsAtOffset(startPos) += sym
-              idx
-        end computeLocalIdx
-        computeLocalIdx(sym)
-      end localIdx
-
-      if sym.exists then
-        if sym.isGlobal then
-          addOwner(sym.owner); addDescriptor(sym)
-        else
-          b.append(Symbols.LocalPrefix).append(localIdx(sym))
-
-    end addSymName
-
-    /** The semanticdb name of the given symbol */
-    private def symbolName(sym: Symbol)(using Context): String =
-      val b = StringBuilder(20)
-      addSymName(b, sym)
-      b.toString
 
     private def range(span: Span, treeSource: SourceFile)(using Context): Option[Range] =
       def lineCol(offset: Int) = (treeSource.offsetToLine(offset), treeSource.column(offset))
       val (startLine, startCol) = lineCol(span.start)
       val (endLine, endCol) = lineCol(span.end)
       Some(Range(startLine, startCol, endLine, endCol))
 
-    private def symbolKind(sym: Symbol, symkinds: Set[SymbolKind])(using Context): SymbolInformation.Kind =
-      if sym.isTypeParam then
-        SymbolInformation.Kind.TYPE_PARAMETER
-      else if sym.is(TermParam) then
-        SymbolInformation.Kind.PARAMETER
-      else if sym.isTerm && sym.owner.isTerm then
-        SymbolInformation.Kind.LOCAL
-      else if sym.isInlineMethod || sym.is(Macro) then
-        SymbolInformation.Kind.MACRO
-      else if sym.isConstructor then
-        SymbolInformation.Kind.CONSTRUCTOR
-      else if sym.isSelfSym then
-        SymbolInformation.Kind.SELF_PARAMETER
-      else if sym.isOneOf(Method) || symkinds.exists(_.isVarOrVal) then
-        SymbolInformation.Kind.METHOD
-      else if sym.isPackageObject then
-        SymbolInformation.Kind.PACKAGE_OBJECT
-      else if sym.is(Module) then
-        SymbolInformation.Kind.OBJECT
-      else if sym.is(Package) then
-        SymbolInformation.Kind.PACKAGE
-      else if sym.isAllOf(JavaInterface) then
-        SymbolInformation.Kind.INTERFACE
-      else if sym.is(Trait) then
-        SymbolInformation.Kind.TRAIT
-      else if sym.isClass then
-        SymbolInformation.Kind.CLASS
-      else if sym.isType then
-        SymbolInformation.Kind.TYPE
-      else if sym.is(ParamAccessor) then
-        SymbolInformation.Kind.FIELD
-      else
-        SymbolInformation.Kind.UNKNOWN_KIND
-
-    private def symbolProps(sym: Symbol, symkinds: Set[SymbolKind])(using Context): Int =
-      if sym.is(ModuleClass) then
-        return symbolProps(sym.sourceModule, symkinds)
-      var props = 0
-      if sym.isPrimaryConstructor then
-        props |= SymbolInformation.Property.PRIMARY.value
-      if sym.is(Abstract) || symkinds.contains(SymbolKind.Abstract) then
-        props |= SymbolInformation.Property.ABSTRACT.value
-      if sym.is(Final) then
-        props |= SymbolInformation.Property.FINAL.value
-      if sym.is(Sealed) then
-        props |= SymbolInformation.Property.SEALED.value
-      if sym.isOneOf(GivenOrImplicit) then
-        props |= SymbolInformation.Property.IMPLICIT.value
-      if sym.is(Lazy, butNot=Module) then
-        props |= SymbolInformation.Property.LAZY.value
-      if sym.isAllOf(Case | Module) || sym.is(CaseClass) || sym.isAllOf(EnumCase) then
-        props |= SymbolInformation.Property.CASE.value
-      if sym.is(Covariant) then
-        props |= SymbolInformation.Property.COVARIANT.value
-      if sym.is(Contravariant) then
-        props |= SymbolInformation.Property.CONTRAVARIANT.value
-      if sym.isAllOf(DefaultMethod | JavaDefined) || sym.is(Accessor) && sym.name.is(NameKinds.DefaultGetterName) then
-        props |= SymbolInformation.Property.DEFAULT.value
-      if symkinds.exists(_.isVal) then
-        props |= SymbolInformation.Property.VAL.value
-      if symkinds.exists(_.isVar) then
-        props |= SymbolInformation.Property.VAR.value
-      if sym.is(JavaStatic) then
-        props |= SymbolInformation.Property.STATIC.value
-      if sym.is(Enum) then
-        props |= SymbolInformation.Property.ENUM.value
-      props
-
-    private def symbolInfo(sym: Symbol, symbolName: String, symkinds: Set[SymbolKind])(using Context): SymbolInformation =
-      SymbolInformation(
-        symbol = symbolName,
-        language = Language.SCALA,
-        kind = symbolKind(sym, symkinds),
-        properties = symbolProps(sym, symkinds),
-        displayName = Symbols.displaySymbol(sym)
-      )
 
-    private def registerSymbol(sym: Symbol, symbolName: String, symkinds: Set[SymbolKind])(using Context): Unit =
-      val isLocal = symbolName.isLocal
-      if !isLocal || !localNames.contains(symbolName) then
+    private def registerSymbol(sym: Symbol, symkinds: Set[SymbolKind])(using Context): Unit =
+      val sname = symbolName(sym)
+      val isLocal = sname.isLocal
+      if !isLocal || !localNames.contains(sname) then
         if isLocal then
-          localNames += symbolName
-        symbolInfos += symbolInfo(sym, symbolName, symkinds)
+          localNames += sname
+        symbolInfos += sym.symbolInfo(symkinds)(using LinkMode.SymlinkChildren)
 
     private def registerSymbolSimple(sym: Symbol)(using Context): Unit =
-      registerSymbol(sym, symbolName(sym), Set.empty)
+      registerSymbol(sym, Set.empty)
 
     private def registerOccurrence(symbol: String, span: Span, role: SymbolOccurrence.Role, treeSource: SourceFile)(using Context): Unit =
       val occ = SymbolOccurrence(range(span, treeSource), symbol, role)
@@ -486,15 +310,15 @@ class ExtractSemanticDB extends Phase:
       registerOccurrence(symbol, span, SymbolOccurrence.Role.REFERENCE, treeSource)
 
     private def registerDefinition(sym: Symbol, span: Span, symkinds: Set[SymbolKind], treeSource: SourceFile)(using Context) =
-      val symbol = symbolName(sym)
+      val sname = symbolName(sym)
       val finalSpan = if !span.hasLength || !sym.is(Given) || namePresentInSource(sym, span, treeSource) then
         span
       else
         Span(span.start)
 
-      registerOccurrence(symbol, finalSpan, SymbolOccurrence.Role.DEFINITION, treeSource)
+      registerOccurrence(sname, finalSpan, SymbolOccurrence.Role.DEFINITION, treeSource)
       if !sym.is(Package) then
-        registerSymbol(sym, symbol, symkinds)
+        registerSymbol(sym, symkinds)
 
     private def namePresentInSource(sym: Symbol, span: Span, source:SourceFile)(using Context): Boolean =
       val content = source.content()
@@ -507,15 +331,6 @@ class ExtractSemanticDB extends Phase:
       val start = if idx >= 0 then idx else span.start
       Span(start, start + sym.name.show.length, start)
 
-    extension (list: List[List[ValDef]])
-      private  inline def isSingleArg = list match
-        case (_::Nil)::Nil => true
-        case _             => false
-
-    extension (tree: DefDef)
-      private def isSetterDef(using Context): Boolean =
-        tree.name.isSetterName && tree.mods.is(Accessor) && tree.termParamss.isSingleArg
-
     private def findGetters(ctorParams: Set[Names.TermName], body: List[Tree])(using Context): Map[Names.TermName, ValDef] =
       if ctorParams.isEmpty || body.isEmpty then
         Map.empty
@@ -562,28 +377,6 @@ class ExtractSemanticDB extends Phase:
     private inline def matchingMemberType(ctorTypeParam: Symbol, classSym: Symbol)(using Context) =
       classSym.info.member(ctorTypeParam.name).symbol
 
-    /**Necessary because not all of the eventual flags are propagated from the Tree to the symbol yet.
-     */
-    private def symbolKinds(tree: NamedDefTree)(using Context): Set[SymbolKind] =
-      if tree.symbol.isSelfSym then
-        Set.empty
-      else
-        val symkinds = mutable.HashSet.empty[SymbolKind]
-        tree match
-        case tree: ValDef =>
-          if !tree.symbol.is(Param) then
-            symkinds += (if tree.mods is Mutable then SymbolKind.Var else SymbolKind.Val)
-          if tree.rhs.isEmpty && !tree.symbol.isOneOf(TermParam | CaseAccessor | ParamAccessor) then
-            symkinds += SymbolKind.Abstract
-        case tree: DefDef =>
-          if tree.isSetterDef then
-            symkinds += SymbolKind.Setter
-          else if tree.rhs.isEmpty then
-            symkinds += SymbolKind.Abstract
-        case tree: Bind =>
-          symkinds += SymbolKind.Val
-        case _ =>
-        symkinds.toSet
 
     private def ctorParams(
       vparamss: List[List[ValDef]], body: List[Tree])(using Context): Unit =
@@ -597,7 +390,7 @@ class ExtractSemanticDB extends Phase:
           val symkinds =
             getters.get(vparam.name).fold(SymbolKind.emptySet)(getter =>
               if getter.mods.is(Mutable) then SymbolKind.VarSet else SymbolKind.ValSet)
-          registerSymbol(vparam.symbol, symbolName(vparam.symbol), symkinds)
+          registerSymbol(vparam.symbol, symkinds)
         traverse(vparam.tpt)
 
 object ExtractSemanticDB:

compiler/src/dotty/tools/dotc/semanticdb/LinkMode.scala

@@ -0,0 +1,4 @@
+package dotty.tools.dotc.semanticdb
+
+enum LinkMode:
+  case SymlinkChildren, HardlinkChildren