Upgrade to tasty-query 0.11.0.

Author: sjrd

build.sbt

@@ -196,8 +196,7 @@ lazy val unpickler3: Project = project
  scalaVersion := Dependencies.scala31Plus,
  Compile / doc / sources := Seq.empty,
  libraryDependencies ++= Seq(
- "ch.epfl.scala" %% "tasty-query" % "0.10.3",
- "org.scala-lang" %% "tasty-core" % scalaVersion.value,
+ "ch.epfl.scala" %% "tasty-query" % "0.11.0",
  Dependencies.asm,
  Dependencies.asmUtil,
  Dependencies.munit % Test

modules/unpickler/src/main/scala/ch/epfl/scala/debugadapter/internal/stacktrace/Scala3Formatter.scala

@@ -88,9 +88,10 @@ class Scala3Formatter(warnLogger: String => Unit, testMode: Boolean)(using Conte
  private def format(name: Name): String =
  def rec(name: Name): String = name match
  case DefaultGetterName(termName, num) => s"${termName.toString()}.<default ${num + 1}>"
- case TypeName(toTermName) => rec(toTermName)
+ case name: TypeName => rec(name.toTermName)
  case SimpleName("$anonfun") => "<anon fun>"
  case SimpleName("$anon") => "<anon class>"
+ case ObjectClassName(underlying) => rec(underlying)
  case _ => name.toString
  rec(name)
 
@@ -113,7 +114,7 @@ class Scala3Formatter(warnLogger: String => Unit, testMode: Boolean)(using Conte
  else if t.isImplicit then "implicit "
  else ""
  s"($prefix$params)$sep$result"
- case t: TypeRef => formatPrefix(t.prefix) + t.name
+ case t: TypeRef => formatPrefix(t.prefix) + format(t.name)
  case t: AppliedType if t.tycon.isFunction =>
  val args = t.args.init.map(format).mkString(", ")
  val result = format(t.args.last)
@@ -134,8 +135,6 @@ class Scala3Formatter(warnLogger: String => Unit, testMode: Boolean)(using Conte
  .map(format)
  .mkString(" " + t.tycon.asInstanceOf[TypeRef].name.toString + " ")
  operatorLikeTypeFormat
- case t: AppliedType if t.tycon.isRepeatedParam =>
- s"${format(t.args.head)}*"
  case t: AppliedType =>
  val tycon = format(t.tycon)
  val args = t.args.map(format).mkString(", ")
@@ -170,19 +169,22 @@ class Scala3Formatter(warnLogger: String => Unit, testMode: Boolean)(using Conte
  s"classOf[${format(t)}]"
  case v => v.toString
  case t: ByNameType => s"=> " + format(t.resultType)
+ case t: RepeatedType => format(t.elemType) + "*"
  case t: TypeRefinement => format(t.parent) + " {...}"
  case t: RecType => format(t.parent)
  case _: WildcardTypeArg => "?"
  case t: TypeLambda =>
  val args = t.paramNames.map(t => t.toString).mkString(", ")
  val result = format(t.resultType)
  s"[$args] =>> $result"
+ case t: NothingType => "Nothing"
+ case t: AnyKindType => "AnyKind"
  case t @ (_: RecThis | _: SkolemType | _: SuperType | _: MatchType | _: CustomTransientGroundType |
  _: PackageRef) =>
  throwOrWarn(s"Cannot format type ${t.getClass.getName}")
  "<unsupported>"
 
- private def formatPolymorphicFunction(t: TermType): String =
+ private def formatPolymorphicFunction(t: TypeOrMethodic): String =
  t match
  case t: PolyType =>
  val args = t.paramNames.mkString(", ")
@@ -192,13 +194,16 @@ class Scala3Formatter(warnLogger: String => Unit, testMode: Boolean)(using Conte
  val params = t.paramTypes.map(format(_)).mkString(", ")
  if t.paramTypes.size > 1 then s"($params) => ${format(t.resultType)}"
  else s"$params => ${format(t.resultType)}"
+ case t: Type =>
+ // for exhaustivity
+ format(t)
 
  private def formatPrefix(p: Prefix): String =
  val prefix = p match
  case NoPrefix => ""
  case p: TermRef if isScalaPredef(p) => ""
  case p: TermRef if isPackageObject(p.name) => ""
- case p: TermRef => formatPrefix(p.prefix) + p.name
+ case p: TermRef => formatPrefix(p.prefix) + format(p.name)
  case p: TermParamRef => p.paramName.toString
  case p: PackageRef => ""
  case p: ThisType => ""

modules/unpickler/src/main/scala/ch/epfl/scala/debugadapter/internal/stacktrace/Scala3Unpickler.scala

@@ -3,7 +3,6 @@ package ch.epfl.scala.debugadapter.internal.stacktrace
 import ch.epfl.scala.debugadapter.internal.binary
 import ch.epfl.scala.debugadapter.internal.jdi.JdiMethod
 import ch.epfl.scala.debugadapter.internal.stacktrace.*
-import tastyquery.Contexts
 import tastyquery.Contexts.Context
 import tastyquery.Names.*
 import tastyquery.Signatures.*
@@ -29,7 +28,7 @@ class Scala3Unpickler(
  testMode: Boolean
 ) extends ThrowOrWarn(warnLogger.accept, testMode):
  private val classpath = ClasspathLoaders.read(classpaths.toList)
- private given ctx: Context = Contexts.init(classpath)
+ private given ctx: Context = Context.initialize(classpath)
  private val defn = new Definitions
  private[stacktrace] val formatter = new Scala3Formatter(warnLogger.accept, testMode)
 
@@ -1001,8 +1000,8 @@ class Scala3Unpickler(
  (!checkTypeErasure || matchTypeErasure(paramsSig, resSig, declaredParams, method.returnType))
 
  private def matchTypeErasure(
- scalaParams: Seq[FullyQualifiedName],
- scalaReturnType: FullyQualifiedName,
+ scalaParams: Seq[SignatureName],
+ scalaReturnType: SignatureName,
  javaParams: Seq[binary.Parameter],
  javaReturnType: Option[binary.Type]
  ): Boolean =
@@ -1025,7 +1024,7 @@ class Scala3Unpickler(
  )
 
  private def matchType(
- scalaType: FullyQualifiedName,
+ scalaType: SignatureName,
  javaType: binary.Type
  ): Boolean =
  def rec(scalaType: String, javaType: String): Boolean =
@@ -1059,4 +1058,12 @@ class Scala3Unpickler(
  .get(scalaType)
  .map(_ == javaType)
  .getOrElse(regex.matches(javaType))
- rec(scalaType.toString, javaType.name)
+ rec(signatureNameToString(scalaType), javaType.name)
+
+ private def signatureNameToString(sigName: SignatureName): String =
+ sigName.items
+ .map {
+ case ObjectClassName(underlying) => underlying
+ case name => name
+ }
+ .mkString(".")

modules/unpickler/src/main/scala/ch/epfl/scala/debugadapter/internal/stacktrace/extensions.scala

@@ -18,7 +18,12 @@ extension (symbol: Symbol)
  def isAnonClass = symbol.nameStr == "$anon"
  def isLocal = symbol.owner.isTerm
  def isModuleClass = symbol.isClass && symbol.asClass.isModuleClass
- def nameStr = symbol.name.toString
+
+ def nameStr = symbol.name match
+ case ObjectClassName(underlying) => underlying.toString()
+ case ObjectClassTypeName(underlying) => underlying.toString()
+ case name => name.toString()
+
  def pos: SourcePosition = symbol.tree.map(_.pos).getOrElse(SourcePosition.NoPosition)
  def isInline = symbol.isTerm && symbol.asTerm.isInline
 
@@ -58,7 +63,7 @@ extension [T <: BinarySymbol](xs: Seq[T])
 
 extension (name: Name)
  def isPackageObject: Boolean =
- val nameStr = name.toString
+ val nameStr = name.toString.stripSuffix("$")
  nameStr == "package" || nameStr.endsWith("$package")
 
 extension (tpe: TermType) def isMethodic: Boolean = tpe.isInstanceOf[MethodicType]
@@ -97,11 +102,6 @@ extension (tpe: Type)
  isScalaPackage(ref.prefix) && ref.nameStr.startsWith("Tuple")
  case _ => false
 
- def isRepeatedParam(using Context): Boolean =
- tpe match
- case ref: TypeRef => ref.optSymbol.exists(_ == ctx.defn.RepeatedParamClass)
- case _ => false
-
  def isOperatorLike: Boolean =
  tpe match
  case ref: TypeRef =>
@@ -113,17 +113,18 @@ extension (tpe: Type)
 extension (tpe: NamedType) def nameStr: String = tpe.name.toString
 
 extension (tpe: TypeOrWildcard)
- def erasedAsReturnType(using Context): FullyQualifiedName = erased(isReturnType = true)
- def erasedAsArgType(asJavaVarargs: Boolean = false)(using Context): FullyQualifiedName =
+ def erasedAsReturnType(using Context): SignatureName = erased(isReturnType = true)
+ def erasedAsArgType(asJavaVarargs: Boolean = false)(using Context): SignatureName =
  tpe match
- case t: AppliedType if t.tycon.isRepeatedParam && asJavaVarargs =>
- AppliedType(TypeRef(ctx.defn.scalaPackage.packageRef, ctx.defn.ArrayClass), t.args).erased(isReturnType = false)
+ case tpe: RepeatedType if asJavaVarargs =>
+ ctx.defn.ArrayTypeOf(tpe.elemType).erased(isReturnType = false)
  case _ => tpe.erased(isReturnType = false)
 
- private def erased(isReturnType: Boolean)(using Context): FullyQualifiedName =
- tpe match
- case tpe: Type => ErasedTypeRef.erase(tpe, SourceLanguage.Scala3, keepUnit = isReturnType).toSigFullName
- case _: WildcardTypeArg => ctx.defn.ObjectClass.fullName
+ private def erased(isReturnType: Boolean)(using Context): SignatureName =
+ val tpe1 = tpe match
+ case tpe: Type => tpe
+ case _: WildcardTypeArg => ctx.defn.ObjectType
+ ErasedTypeRef.erase(tpe1, SourceLanguage.Scala3, keepUnit = isReturnType).toSigFullName
 
 extension (ref: TermRef)
  def isScalaPredef: Boolean =