Merge pull request #14608 from tanishiking/typelambda-matchtype-2

Support MatchType for SemanticDB

Author: bishabosha

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

@@ -234,7 +234,12 @@ class ExtractSemanticDB extends Phase:
           val sym = tree.symbol.adjustIfCtorTyparam
           if qualSpan.exists && qualSpan.hasLength then
             traverse(qual)
-          registerUseGuarded(qual.symbol.ifExists, sym, selectSpan(tree), tree.source)
+          if (sym != NoSymbol)
+            registerUseGuarded(qual.symbol.ifExists, sym, selectSpan(tree), tree.source)
+          else
+            qual.symbol.info.lookupSym(tree.name).foreach(sym =>
+              registerUseGuarded(qual.symbol.ifExists, sym, selectSpan(tree), tree.source)
+            )
         case tree: Import =>
           if tree.span.exists && tree.span.hasLength then
             traverseChildren(tree)
@@ -422,19 +427,22 @@ 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 tree: Bind if (tree.symbol.isType) =>
+            symkinds += SymbolKind.TypeVal
+          case _ =>
         symkinds.toSet
 
     private def ctorParams(

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

@@ -191,7 +191,12 @@ 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 x =>
           "<?>"
 
       def normal(tpe: Type): String = tpe match

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

@@ -12,6 +12,7 @@ import core.StdNames.nme
 import SymbolInformation.{Kind => k}
 import dotty.tools.dotc.util.SourceFile
 import dotty.tools.dotc.util.Spans.Span
+import dotty.tools.dotc.core.Names.Designator
 
 import java.lang.Character.{isJavaIdentifierPart, isJavaIdentifierStart}
 
@@ -34,23 +35,30 @@ object Scala3:
     val (endLine, endCol) = lineCol(span.end)
     Some(Range(startLine, startCol, endLine, endCol))
 
-  def namePresentInSource(sym: Symbol, span: Span, source:SourceFile)(using Context): Boolean =
+  def namePresentInSource(desig: Designator, span: Span, source:SourceFile)(using Context): Boolean =
     if !span.exists then false
     else
       val content = source.content()
       val (start, end) =
         if content.lift(span.end - 1).exists(_ == '`') then
           (span.start + 1, span.end - 1)
         else (span.start, span.end)
+      // println(s"${start}, $end")
       val nameInSource = content.slice(start, end).mkString
       // for secondary constructors `this`
-      if sym.isConstructor && nameInSource == nme.THISkw.toString then
-        true
-      else
-        val target =
-          if sym.isPackageObject then sym.owner
-          else sym
-        nameInSource == target.name.stripModuleClassSuffix.lastPart.toString
+      desig match
+        case sym: Symbol =>
+          if sym.isConstructor && nameInSource == nme.THISkw.toString then
+            true
+          else
+            val target =
+              if sym.isPackageObject then sym.owner
+              else sym
+            nameInSource == target.name.stripModuleClassSuffix.lastPart.toString
+        case name: Name =>
+          // println(nameInSource)
+          // println(name.mangledString)
+          nameInSource == name.mangledString
 
   sealed trait FakeSymbol {
     private[Scala3] var sname: Option[String] = None
@@ -153,12 +161,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 +318,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

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._
@@ -33,7 +34,7 @@ class TypeOps:
     )(using Context): Option[Symbol] =
       symtab.get((binder, name))
 
-  extension [T <: LambdaType](symtab: mutable.Map[(T, Name), Symbol])
+  extension [T <: LambdaType | RefinedType](symtab: mutable.Map[(T, Name), Symbol])
     private def lookupOrErr(
       binder: T,
       name: Name,
@@ -53,6 +54,8 @@ class TypeOps:
 
   private def symbolNotFound(binder: Type, name: Name, parent: Symbol)(using ctx: Context): Unit =
     warn(s"Ignoring ${name} of symbol ${parent}, type ${binder}")
+  private def symbolNotFound(name: Name, parent: Symbol)(using ctx: Context): Unit =
+    warn(s"Ignoring ${name} of symbol ${parent}")
 
   private def warn(msg: String)(using ctx: Context): Unit =
     report.warning(
@@ -63,6 +66,23 @@ class TypeOps:
     fakeSymbols.add(sym)
 
   extension (tpe: Type)
+    def lookupSym(name: Name)(using Context): Option[Symbol] = {
+      def loop(ty: Type): Option[Symbol] = ty match
+        case rt: RefinedType =>
+          refinementSymtab.lookup(rt, name).orElse(
+            loop(rt.parent)
+          )
+        case rec: RecType =>
+          loop(rec.parent)
+        case AndType(tp1, tp2) =>
+          loop(tp1).orElse(loop(tp2))
+        case OrType(tp1, tp2) =>
+          loop(tp1).orElse(loop(tp2))
+        case _ =>
+          None
+      loop(tpe.dealias)
+    }
+
     def toSemanticSig(using LinkMode, Context, SemanticSymbolBuilder)(sym: Symbol): s.Signature =
       def enterParamRef(tpe: Type): Unit =
         tpe match {
@@ -81,6 +101,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] =>
@@ -137,6 +161,12 @@ class TypeOps:
             enterRefined(expr.resType)
           case m: LambdaType =>
             enterRefined(m.resType)
+          case AndType(t1, t2) =>
+            enterRefined(t1)
+            enterRefined(t2)
+          case OrType(t1, t2) =>
+            enterRefined(t1)
+            enterRefined(t2)
           case _ => ()
         }
       if sym.exists && sym.owner.exists then
@@ -223,16 +253,42 @@ class TypeOps:
           val stpe = loop(tpe)
           s.ByNameType(stpe)
 
-        case TypeRef(pre, sym: Symbol) =>
+        // sym of `TypeRef(_, sym)` may not be a Symbol but Name in some cases
+        // e.g. in MatchType,
+        // case x *: xs => x *: Concat[xs, Ys]
+        // x and xs should have a typebounds <: Any, >: Nothing
+        // but Any (and Nothing) are represented as TypeRef(<scala>, "Any" <- Name)
+        case tr @ TypeRef(pre, _) if tr.symbol != NoSymbol =>
           val spre = if tpe.hasTrivialPrefix then s.Type.Empty else loop(pre)
-          val ssym = sym.symbolName
+          val ssym = tr.symbol.symbolName
           s.TypeRef(spre, ssym, Seq.empty)
 
-        case TermRef(pre, sym: Symbol) =>
+        // when TypeRef refers the refinement of RefinedType e.g.
+        // TypeRef for `foo.B` in `trait T[A] { val foo: { type B = A } = ???; def bar(b: foo.B) = () }` has NoSymbol
+        case TypeRef(pre, name: Name) =>
+          val spre = if tpe.hasTrivialPrefix then s.Type.Empty else loop(pre)
+          val maybeSym = pre.widen.dealias.lookupSym(name)
+          maybeSym match
+            case Some(sym) =>
+              s.TypeRef(spre, sym.symbolName, Seq.empty)
+            case None => s.Type.Empty
+
+        case tr @ TermRef(pre, _) if tr.symbol != NoSymbol =>
           val spre = if(tpe.hasTrivialPrefix) s.Type.Empty else loop(pre)
-          val ssym = sym.symbolName
+          val ssym = tr.symbol.symbolName
           s.SingleType(spre, ssym)
 
+        case TermRef(pre, name: Name) =>
+          val spre = if tpe.hasTrivialPrefix then s.Type.Empty else loop(pre)
+          val maybeSym = pre.widen.dealias match
+            case rt: RefinedType =>
+              refinementSymtab.lookupOrErr(rt, name, rt.typeSymbol)
+            case _ => None
+          maybeSym match
+            case Some(sym) =>
+              s.SingleType(spre, sym.symbolName)
+            case None => s.Type.Empty
+
         case ThisType(TypeRef(_, sym: Symbol)) =>
           s.ThisType(sym.symbolName)
 
@@ -276,6 +332,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 +486,6 @@ class TypeOps:
         // Not yet supported
         case _: HKTypeLambda =>
           s.Type.Empty
-        case _: MatchType =>
-          s.Type.Empty
 
         case tvar: TypeVar =>
           loop(tvar.stripped)
@@ -423,8 +502,12 @@ class TypeOps:
       tpe match {
         case TypeRef(pre, sym: Symbol) =>
           checkTrivialPrefix(pre, sym)
+        case tr @ TypeRef(pre, _) if tr.symbol != NoSymbol =>
+          checkTrivialPrefix(pre, tr.symbol)
         case TermRef(pre, sym: Symbol) =>
           checkTrivialPrefix(pre, sym)
+        case tr @ TermRef(pre, _) if tr.symbol != NoSymbol =>
+          checkTrivialPrefix(pre, tr.symbol)
         case _ => false
       }