Remove case property from the symbol of type variable

`t` of `case List[t] =>` has `CaseClass` flag.
Maybe we should remove `CaseClass` flag from `t`, but as a workaround
remove `Case` property from semanticdb from type variables.

Author: tanishiking

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

@@ -433,6 +433,8 @@ class ExtractSemanticDB extends Phase:
           // if symbol isType, it's type variable
           case tree: Bind if (!tree.symbol.isType) =>
             symkinds += SymbolKind.Val
+          case tree: Bind if (tree.symbol.isType) =>
+            symkinds += SymbolKind.TypeVal
           case _ =>
         symkinds.toSet
 

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

@@ -153,12 +153,13 @@ object Scala3:
   enum SymbolKind derives CanEqual:
     kind =>
 
-    case Val, Var, Setter, Abstract
+    case Val, Var, Setter, Abstract, TypeVal
 
     def isVar: Boolean = kind match
       case Var | Setter => true
       case _            => false
     def isVal: Boolean = kind == Val
+    def isTypeVal: Boolean = kind == TypeVal
     def isVarOrVal: Boolean = kind.isVar || kind.isVal
 
   end SymbolKind
@@ -309,7 +310,9 @@ object Scala3:
           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
+        if sym.isAllOf(Case | Module) ||
+          (sym.is(CaseClass) && !symkinds.exists(_.isTypeVal)) || // `t` of `case List[t] =>` (which has `CaseClass` flag) shouldn't be `CASE`
+          sym.isAllOf(EnumCase) then
           props |= SymbolInformation.Property.CASE.value
         if sym.is(Covariant) then
           props |= SymbolInformation.Property.COVARIANT.value

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 type t 
-local1 => case type t 
-local2 => case type x 
-local3 => case type xs  <: Tuple
+local0 => type t 
+local1 => type t 
+local2 => type x 
+local3 => type xs  <: Tuple
 
 Occurrences:
 [0:8..0:15): example <- example/
@@ -4087,9 +4087,9 @@ Occurrences => 46 entries
 Synthetics => 3 entries
 
 Symbols:
-local0 => case type N$1  <: Nat
+local0 => type N$1  <: Nat
 local1 => val local p: N$1
-local2 => case type N$2  <: Nat
+local2 => 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 type t 
+local1 => type t 
 
 Occurrences:
 [0:8..0:13): flags <- flags/