Support MatchType in semanticdb

Author: tanishiking

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

@@ -125,7 +125,8 @@ class SymbolInformationPrinter (symtab: PrinterSymtab):
           if (tparams.infos.nonEmpty)
             sb.append(tparams.infos.map(pprintDef).mkString("[", ", ", "]"))
           if (lo == hi) {
-            sb.append(s" = ${pprint(lo)}")
+            if (lo == Type.Empty) ()
+            else sb.append(s" = ${pprint(lo)}")
           } else {
             lo match
               case TypeRef(Type.Empty, "scala/Nothing#", Nil) => ()
@@ -191,7 +192,16 @@ class SymbolInformationPrinter (symtab: PrinterSymtab):
           s"=> ${normal(utpe)}"
         case RepeatedType(utpe) =>
           s"${normal(utpe)}*"
-        case _ =>
+        case MatchType(scrutinee, cases) =>
+          val casesStr = cases.map { caseType =>
+            s"${pprint(caseType.key)} => ${pprint(caseType.body)}"
+          }.mkString(", ")
+          s"${pprint(scrutinee)} match { ${casesStr} }"
+        case LambdaType(params, result) =>
+          val paramsStr = params.infos.map(pprintDef).mkString("[", ", ", "]")
+          val resultStr = pprint(result)
+          s"${paramsStr} =>> ${resultStr}"
+        case x =>
           "<?>"
 
       def normal(tpe: Type): String = tpe match

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

@@ -15,6 +15,7 @@ import collection.mutable
 
 import dotty.tools.dotc.{semanticdb => s}
 import Scala3.{FakeSymbol, SemanticSymbol, WildcardTypeSymbol, TypeParamRefSymbol, TermParamRefSymbol, RefinementSymbol}
+import dotty.tools.dotc.core.Names.Designator
 
 class TypeOps:
   import SymbolScopeOps._
@@ -81,6 +82,10 @@ class TypeOps:
             else
               enterParamRef(lam.resType)
 
+          // for CaseType `case Array[t] => t` which is represented as [t] =>> MatchCase[Array[t], t]
+          case m: MatchType =>
+            m.cases.foreach(enterParamRef)
+
           // for class constructor
           // class C[T] { ... }
           case cls: ClassInfo if sym.info.isInstanceOf[LambdaType] =>
@@ -276,6 +281,31 @@ class TypeOps:
         case ConstantType(const) =>
           s.ConstantType(const.toSemanticConst)
 
+        case matchType: MatchType =>
+          val scases = matchType.cases.map { caseType => caseType match {
+            case lam: HKTypeLambda => // case Array[t] => t
+              val paramSyms = lam.paramNames.flatMap { paramName =>
+                val key = (lam, paramName)
+                paramRefSymtab.get(key)
+              }.sscope
+              lam.resType match {
+                case defn.MatchCase(key, body) =>
+                  s.MatchType.CaseType(
+                    loop(key),
+                    loop(body)
+                  )
+                case _ => s.MatchType.CaseType() // shouldn't happen
+              }
+            case defn.MatchCase(key, body) =>
+              val skey = loop(key)
+              val sbody = loop(body)
+              s.MatchType.CaseType(skey, sbody)
+            case _ => s.MatchType.CaseType() // shouldn't happen
+          }}
+          val sscrutinee = loop(matchType.scrutinee)
+          val sbound = loop(matchType.bound)
+          s.MatchType(sscrutinee, scases)
+
         case rt @ RefinedType(parent, name, info) =>
           // `X { def x: Int; def y: Int }`
           // RefinedType(
@@ -405,8 +435,6 @@ class TypeOps:
         // Not yet supported
         case _: HKTypeLambda =>
           s.Type.Empty
-        case _: MatchType =>
-          s.Type.Empty
 
         case tvar: TypeVar =>
           loop(tvar.stripped)

tests/semanticdb/expect/MatchType.expect.scala

@@ -0,0 +1,10 @@
+package example
+
+type Elem/*<-example::MatchType$package.Elem#*/[X/*<-example::MatchType$package.Elem#[X]*/] = X/*->example::MatchType$package.Elem#[X]*/ match
+  case String/*->scala::Predef.String#*/ => Char/*->scala::Char#*/
+  case Array/*->scala::Array#*/[t/*<-local0*/] => t/*->local0*/
+  case Iterable/*->scala::package.Iterable#*/[t/*<-local1*/] => t/*->local1*/
+
+type Concat/*<-example::MatchType$package.Concat#*/[Xs/*<-example::MatchType$package.Concat#[Xs]*/ <: Tuple/*->scala::Tuple#*/, +Ys/*<-example::MatchType$package.Concat#[Ys]*/ <: Tuple/*->scala::Tuple#*/] <: Tuple/*->scala::Tuple#*/ = Xs/*->example::MatchType$package.Concat#[Xs]*/ match
+  case EmptyTuple/*->scala::Tuple$package.EmptyTuple#*/ => Ys/*->example::MatchType$package.Concat#[Ys]*/
+  case x/*<-local2*/ *:/*->scala::`*:`#*/ xs/*<-local3*/ => x/*->local2*/ *:/*->scala::`*:`#*/ Concat/*->example::MatchType$package.Concat#*/[xs/*->local3*/, Ys/*->example::MatchType$package.Concat#[Ys]*/]

tests/semanticdb/expect/MatchType.scala

@@ -0,0 +1,10 @@
+package example
+
+type Elem[X] = X match
+  case String => Char
+  case Array[t] => t
+  case Iterable[t] => t
+
+type Concat[Xs <: Tuple, +Ys <: Tuple] <: Tuple = Xs match
+  case EmptyTuple => Ys
+  case x *: xs => x *: Concat[xs, Ys]

tests/semanticdb/metac.expect

@@ -2016,6 +2016,60 @@ Occurrences:
 Synthetics:
 [5:4..5:8):List => *.apply[Int]
 
+expect/MatchType.scala
+----------------------
+
+Summary:
+Schema => SemanticDB v4
+Uri => MatchType.scala
+Text => empty
+Language => Scala
+Symbols => 10 entries
+Occurrences => 29 entries
+
+Symbols:
+example/MatchType$package. => final package object example extends Object { self: example.type => +3 decls }
+example/MatchType$package.Concat# => type Concat [typeparam Xs  <: Tuple, covariant typeparam Ys  <: Tuple] = Xs match { EmptyTuple => Ys, *:[x, xs] => *:[x, Concat[xs, Ys]] }
+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 
+
+Occurrences:
+[0:8..0:15): example <- example/
+[2:5..2:9): Elem <- example/MatchType$package.Elem#
+[2:10..2:11): X <- example/MatchType$package.Elem#[X]
+[2:15..2:16): X -> example/MatchType$package.Elem#[X]
+[3:7..3:13): String -> scala/Predef.String#
+[3:17..3:21): Char -> scala/Char#
+[4:7..4:12): Array -> scala/Array#
+[4:13..4:14): t <- local0
+[4:19..4:20): t -> local0
+[5:7..5:15): Iterable -> scala/package.Iterable#
+[5:16..5:17): t <- local1
+[5:22..5:23): t -> local1
+[7:5..7:11): Concat <- example/MatchType$package.Concat#
+[7:12..7:14): Xs <- example/MatchType$package.Concat#[Xs]
+[7:18..7:23): Tuple -> scala/Tuple#
+[7:26..7:28): Ys <- example/MatchType$package.Concat#[Ys]
+[7:32..7:37): Tuple -> scala/Tuple#
+[7:42..7:47): Tuple -> scala/Tuple#
+[7:50..7:52): Xs -> example/MatchType$package.Concat#[Xs]
+[8:7..8:17): EmptyTuple -> scala/Tuple$package.EmptyTuple#
+[8:21..8:23): Ys -> example/MatchType$package.Concat#[Ys]
+[9:7..9:8): x <- local2
+[9:9..9:11): *: -> scala/`*:`#
+[9:12..9:14): xs <- local3
+[9:18..9:19): x -> local2
+[9:20..9:22): *: -> scala/`*:`#
+[9:23..9:29): Concat -> example/MatchType$package.Concat#
+[9:30..9:32): xs -> local3
+[9:34..9:36): Ys -> example/MatchType$package.Concat#[Ys]
+
 expect/MetacJava.scala
 ----------------------