Assign types to type variables in match case types

Author: tanishiking

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

@@ -420,19 +420,20 @@ class ExtractSemanticDB extends Phase:
       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 _ =>
+          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
+          // if symbol isType, it's type variable
+          case tree: Bind if (!tree.symbol.isType) =>
+            symkinds += SymbolKind.Val
+          case _ =>
         symkinds.toSet
 
     private def ctorParams(

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

@@ -125,8 +125,7 @@ class SymbolInformationPrinter (symtab: PrinterSymtab):
           if (tparams.infos.nonEmpty)
             sb.append(tparams.infos.map(pprintDef).mkString("[", ", ", "]"))
           if (lo == hi) {
-            if (lo == Type.Empty) ()
-            else sb.append(s" = ${pprint(lo)}")
+            sb.append(s" = ${pprint(lo)}")
           } else {
             lo match
               case TypeRef(Type.Empty, "scala/Nothing#", Nil) => ()

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

@@ -233,6 +233,14 @@ class TypeOps:
           val ssym = sym.symbolName
           s.TypeRef(spre, ssym, Seq.empty)
 
+        case TypeRef(pre, sym: Name) =>
+          // val spre = if tpe.hasTrivialPrefix then s.Type.Empty else loop(pre)
+          // Craft semanticdb symbol
+          // prefix symbol (e.g. "scala/") + name (e.g. "Nothing") + Global symbol suffix ("#")
+          // see: https://scalameta.org/docs/semanticdb/specification.html#symbol
+          val ssym = s"${pre.typeSymbol.symbolName}${sym.mangledString}#"
+          s.TypeRef(s.Type.Empty, ssym, Seq.empty)
+
         case TermRef(pre, sym: Symbol) =>
           val spre = if(tpe.hasTrivialPrefix) s.Type.Empty else loop(pre)
           val ssym = sym.symbolName

tests/semanticdb/metac.expect

@@ -2034,10 +2034,10 @@ example/MatchType$package.Concat#[Xs] => typeparam Xs  <: Tuple
 example/MatchType$package.Concat#[Ys] => covariant typeparam Ys  <: Tuple
 example/MatchType$package.Elem# => type Elem [typeparam X ] = X match { String => Char, Array[t] => t, Iterable[t] => t }
 example/MatchType$package.Elem#[X] => typeparam X 
-local0 => case val method t 
-local1 => case val method t 
-local2 => case val method x 
-local3 => case val method xs 
+local0 => case type t 
+local1 => case type t 
+local2 => case type x 
+local3 => case type xs  <: Tuple
 
 Occurrences:
 [0:8..0:15): example <- example/
@@ -4087,9 +4087,9 @@ Occurrences => 46 entries
 Synthetics => 3 entries
 
 Symbols:
-local0 => case val method N$1  <: Nat
+local0 => case type N$1  <: Nat
 local1 => val local p: N$1
-local2 => case val method N$2  <: Nat
+local2 => case type N$2  <: Nat
 local3 => val local p: N$2
 local4 => val local Nat_this: Zero.type
 local5 => val local Nat_this: Succ[Zero.type]
@@ -4271,7 +4271,7 @@ flags/p/package.y(). => protected implicit var method y Int
 flags/p/package.z(). => method z (param pp: Int): Int
 flags/p/package.z().(pp) => param pp: Int
 local0 => val local xs2: Nothing
-local1 => case val method t 
+local1 => case type t 
 
 Occurrences:
 [0:8..0:13): flags <- flags/