chore: LTS backports (#20855)

Author: WojciechMazur

compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala

@@ -793,6 +793,9 @@ class JSCodeGen()(using genCtx: Context) {
         name.name
     }.toSet
 
+    val staticNames = moduleClass.companionClass.info.allMembers
+      .collect { case d if d.name.isTermName && d.symbol.isScalaStatic => d.name }.toSet
+
     val members = {
       moduleClass.info.membersBasedOnFlags(required = Flags.Method,
           excluded = Flags.ExcludedForwarder).map(_.symbol)
@@ -815,6 +818,7 @@ class JSCodeGen()(using genCtx: Context) {
         || hasAccessBoundary
         || isOfJLObject
         || m.hasAnnotation(jsdefn.JSNativeAnnot) || isDefaultParamOfJSNativeDef // #4557
+        || staticNames(m.name)
     }
 
     val forwarders = for {
@@ -4769,7 +4773,7 @@ class JSCodeGen()(using genCtx: Context) {
   }
 
   private def isMethodStaticInIR(sym: Symbol): Boolean =
-    sym.is(JavaStatic)
+    sym.is(JavaStatic) || sym.isScalaStatic
 
   /** Generate a Class[_] value (e.g. coming from classOf[T]) */
   private def genClassConstant(tpe: Type)(implicit pos: Position): js.Tree =

compiler/src/dotty/tools/dotc/Run.scala

@@ -342,6 +342,8 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
     runCtx.setProfiler(Profiler())
     unfusedPhases.foreach(_.initContext(runCtx))
     val fusedPhases = runCtx.base.allPhases
+    if ctx.settings.explainCyclic.value then
+      runCtx.setProperty(CyclicReference.Trace, new CyclicReference.Trace())
     runCtx.withProgressCallback: cb =>
       _progress = Progress(cb, this, fusedPhases.map(_.traversals).sum)
     runPhases(allPhases = fusedPhases)(using runCtx)

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -118,6 +118,7 @@ trait CommonScalaSettings:
   // -explain-types setting is necessary for cross compilation, since it is mentioned in sbt-tpolecat, for instance
   // it is otherwise subsumed by -explain, and should be dropped as soon as we can.
   val explainTypes: Setting[Boolean] = BooleanSetting("-explain-types", "Explain type errors in more detail (deprecated, use -explain instead).", aliases = List("--explain-types", "-explaintypes"))
+  val explainCyclic: Setting[Boolean] = BooleanSetting("-explain-cyclic", "Explain cyclic reference errors in more detail.", aliases = List("--explain-cyclic"))
   val unchecked: Setting[Boolean] = BooleanSetting("-unchecked", "Enable additional warnings where generated code depends on assumptions.", initialValue = true, aliases = List("--unchecked"))
   val language: Setting[List[String]] = MultiStringSetting("-language", "feature", "Enable one or more language features.", aliases = List("--language"))
 
@@ -347,6 +348,7 @@ private sealed trait YSettings:
   val YdebugTypeError: Setting[Boolean] = BooleanSetting("-Ydebug-type-error", "Print the stack trace when a TypeError is caught", false)
   val YdebugError: Setting[Boolean] = BooleanSetting("-Ydebug-error", "Print the stack trace when any error is caught.", false)
   val YdebugUnpickling: Setting[Boolean] = BooleanSetting("-Ydebug-unpickling", "Print the stack trace when an error occurs when reading Tasty.", false)
+  val YdebugCyclic: Setting[Boolean] = BooleanSetting("-Ydebug-cyclic", "Print the stack trace when a cyclic reference error occurs.", false)
   val YtermConflict: Setting[String] = ChoiceSetting("-Yresolve-term-conflict", "strategy", "Resolve term conflicts", List("package", "object", "error"), "error")
   val Ylog: Setting[List[String]] = PhasesSetting("-Ylog", "Log operations during")
   val YlogClasspath: Setting[Boolean] = BooleanSetting("-Ylog-classpath", "Output information about what classpath is being applied.")

compiler/src/dotty/tools/dotc/core/SymDenotations.scala

@@ -166,12 +166,17 @@ object SymDenotations {
             println(i"${"  " * indent}completed $name in $owner")
           }
         }
-        else {
-          if (myFlags.is(Touched))
-            throw CyclicReference(this)(using ctx.withOwner(symbol))
-          myFlags |= Touched
-          atPhase(validFor.firstPhaseId)(completer.complete(this))
-        }
+        else
+          val traceCycles = CyclicReference.isTraced
+          try
+            if traceCycles then
+              CyclicReference.pushTrace("compute the signature of ", symbol, "")
+            if myFlags.is(Touched) then
+              throw CyclicReference(this)(using ctx.withOwner(symbol))
+            myFlags |= Touched
+            atPhase(validFor.firstPhaseId)(completer.complete(this))
+          finally
+            if traceCycles then CyclicReference.popTrace()
 
     protected[dotc] def info_=(tp: Type): Unit = {
       /* // DEBUG
@@ -2965,7 +2970,10 @@ object SymDenotations {
     def apply(clsd: ClassDenotation)(implicit onBehalf: BaseData, ctx: Context)
         : (List[ClassSymbol], BaseClassSet) = {
       assert(isValid)
+      val traceCycles = CyclicReference.isTraced
       try
+        if traceCycles then
+          CyclicReference.pushTrace("compute the base classes of ", clsd.symbol, "")
         if (cache != null) cache.uncheckedNN
         else {
           if (locked) throw CyclicReference(clsd)
@@ -2978,7 +2986,9 @@ object SymDenotations {
           else onBehalf.signalProvisional()
           computed
         }
-      finally addDependent(onBehalf)
+      finally
+        if traceCycles then CyclicReference.popTrace()
+        addDependent(onBehalf)
     }
 
     def sameGroup(p1: Phase, p2: Phase) = p1.sameParentsStartId == p2.sameParentsStartId

compiler/src/dotty/tools/dotc/core/Symbols.scala

@@ -129,7 +129,7 @@ object Symbols extends SymUtils {
     final def lastKnownDenotation: SymDenotation =
       lastDenot
 
-    private[core] def defRunId: RunId =
+    private[dotc] def defRunId: RunId =
       lastDenot.validFor.runId
 
     private inline def associatedFileMatches(inline filter: AbstractFile => Boolean)(using Context): Boolean =

compiler/src/dotty/tools/dotc/core/TypeErrors.scala

@@ -12,7 +12,9 @@ import Denotations.*
 import Decorators.*
 import reporting.*
 import ast.untpd
+import util.Property
 import config.Printers.{cyclicErrors, noPrinter}
+import collection.mutable
 
 import scala.annotation.constructorOnly
 
@@ -27,6 +29,7 @@ abstract class TypeError(using creationContext: Context) extends Exception(""):
     || ctx.settings.YdebugTypeError.value
     || ctx.settings.YdebugError.value
     || ctx.settings.YdebugUnpickling.value
+    || ctx.settings.YdebugCyclic.value
 
   override def fillInStackTrace(): Throwable =
     if computeStackTrace then super.fillInStackTrace().nn
@@ -72,8 +75,7 @@ extends TypeError:
   def explanation: String = s"$op $details"
 
   private def recursions: List[RecursionOverflow] = {
-    import scala.collection.mutable.ListBuffer
-    val result = ListBuffer.empty[RecursionOverflow]
+    val result = mutable.ListBuffer.empty[RecursionOverflow]
     @annotation.tailrec def loop(throwable: Throwable): List[RecursionOverflow] = throwable match {
       case ro: RecursionOverflow =>
         result += ro
@@ -135,7 +137,10 @@ end handleRecursive
  * so it requires knowing denot already.
  * @param denot
  */
-class CyclicReference(val denot: SymDenotation)(using Context) extends TypeError:
+class CyclicReference(
+    val denot: SymDenotation,
+    val optTrace: Option[Array[CyclicReference.TraceElement]])(using Context)
+extends TypeError:
   var inImplicitSearch: Boolean = false
 
   val cycleSym = denot.symbol
@@ -161,11 +166,11 @@ class CyclicReference(val denot: SymDenotation)(using Context) extends TypeError
         cx.tree match {
           case tree: untpd.ValOrDefDef if !tree.tpt.typeOpt.exists =>
             if (inImplicitSearch)
-              TermMemberNeedsResultTypeForImplicitSearch(cycleSym)
+              TermMemberNeedsResultTypeForImplicitSearch(this)
             else if (isMethod)
-              OverloadedOrRecursiveMethodNeedsResultType(cycleSym)
+              OverloadedOrRecursiveMethodNeedsResultType(this)
             else if (isVal)
-              RecursiveValueNeedsResultType(cycleSym)
+              RecursiveValueNeedsResultType(this)
             else
               errorMsg(cx.outer)
           case _ =>
@@ -174,22 +179,38 @@ class CyclicReference(val denot: SymDenotation)(using Context) extends TypeError
 
       // Give up and give generic errors.
       else if (cycleSym.isOneOf(GivenOrImplicitVal, butNot = Method) && cycleSym.owner.isTerm)
-        CyclicReferenceInvolvingImplicit(cycleSym)
+        CyclicReferenceInvolvingImplicit(this)
       else
-        CyclicReferenceInvolving(denot)
+        CyclicReferenceInvolving(this)
 
     errorMsg(ctx)
   end toMessage
 
 object CyclicReference:
+
   def apply(denot: SymDenotation)(using Context): CyclicReference =
-    val ex = new CyclicReference(denot)
+    val ex = new CyclicReference(denot, ctx.property(Trace).map(_.toArray))
     if ex.computeStackTrace then
       cyclicErrors.println(s"Cyclic reference involving! $denot")
       val sts = ex.getStackTrace.asInstanceOf[Array[StackTraceElement]]
       for (elem <- sts take 200)
         cyclicErrors.println(elem.toString)
     ex
+
+  type TraceElement = (/*prefix:*/ String, Symbol, /*suffix:*/ String)
+  type Trace = mutable.ArrayBuffer[TraceElement]
+  val Trace = Property.Key[Trace]
+
+  def isTraced(using Context) =
+    ctx.property(CyclicReference.Trace).isDefined
+
+  def pushTrace(info: TraceElement)(using Context): Unit =
+    for buf <- ctx.property(CyclicReference.Trace) do
+      buf += info
+
+  def popTrace()(using Context): Unit =
+    for buf <- ctx.property(CyclicReference.Trace) do
+      buf.dropRightInPlace(1)
 end CyclicReference
 
 class UnpicklingError(denot: Denotation, where: String, cause: Throwable)(using Context) extends TypeError:

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -640,6 +640,8 @@ object Types extends TypeUtils {
             tp.superType.baseClasses
           case tp: ClassInfo =>
             tp.cls.classDenot.baseClasses
+          case tp: WildcardType =>
+            tp.effectiveBounds.hi.baseClasses
           case _ => Nil
       catch case ex: Throwable =>
         handleRecursive("base classes of", this.show, ex)

compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala

@@ -124,20 +124,25 @@ class TreeUnpickler(reader: TastyReader,
     val mode = ctx.mode
     val source = ctx.source
     def complete(denot: SymDenotation)(using Context): Unit =
-      def fail(ex: Throwable) =
-        def where =
-          val f = denot.symbol.associatedFile
-          if f == null then "" else s" in $f"
-        throw UnpicklingError(denot, where, ex)
+      def where =
+        val f = denot.symbol.associatedFile
+        if f == null then "" else s" in $f"
+      def fail(ex: Throwable) = throw UnpicklingError(denot, where, ex)
       treeAtAddr(currentAddr) =
+        val traceCycles = CyclicReference.isTraced
         try
+          if traceCycles then
+            CyclicReference.pushTrace("read the definition of ", denot.symbol, where)
           atPhaseBeforeTransforms {
             new TreeReader(reader).readIndexedDef()(
               using ctx.withOwner(owner).withModeBits(mode).withSource(source))
           }
         catch
+          case ex: CyclicReference => throw ex
           case ex: AssertionError => fail(ex)
           case ex: Exception => fail(ex)
+        finally
+          if traceCycles then CyclicReference.popTrace()
   }
 
   class TreeReader(val reader: TastyReader) {

compiler/src/dotty/tools/dotc/interactive/Completion.scala

@@ -184,12 +184,12 @@ object Completion:
     val completions = adjustedPath match
         // Ignore synthetic select from `This` because in code it was `Ident`
         // See example in dotty.tools.languageserver.CompletionTest.syntheticThis
-        case Select(qual @ This(_), _) :: _ if qual.span.isSynthetic  => completer.scopeCompletions
-        case Select(qual, _) :: _           if qual.tpe.hasSimpleKind => completer.selectionCompletions(qual)
-        case Select(qual, _) :: _                                     => Map.empty
-        case (tree: ImportOrExport) :: _                              => completer.directMemberCompletions(tree.expr)
-        case (_: untpd.ImportSelector) :: Import(expr, _) :: _        => completer.directMemberCompletions(expr)
-        case _                                                        => completer.scopeCompletions
+        case Select(qual @ This(_), _) :: _ if qual.span.isSynthetic      => completer.scopeCompletions
+        case Select(qual, _) :: _           if qual.typeOpt.hasSimpleKind => completer.selectionCompletions(qual)
+        case Select(qual, _) :: _                                         => Map.empty
+        case (tree: ImportOrExport) :: _                                  => completer.directMemberCompletions(tree.expr)
+        case (_: untpd.ImportSelector) :: Import(expr, _) :: _            => completer.directMemberCompletions(expr)
+        case _                                                            => completer.scopeCompletions
 
     val describedCompletions = describeCompletions(completions)
     val backtickedCompletions =
@@ -348,7 +348,7 @@ object Completion:
     /** Widen only those types which are applied or are exactly nothing
      */
     def widenQualifier(qual: Tree)(using Context): Tree =
-      qual.tpe.widenDealias match
+      qual.typeOpt.widenDealias match
         case widenedType if widenedType.isExactlyNothing => qual.withType(widenedType)
         case appliedType: AppliedType => qual.withType(appliedType)
         case _ => qual
@@ -368,10 +368,10 @@ object Completion:
      *  These include inherited definitions but not members added by extensions or implicit conversions
      */
     def directMemberCompletions(qual: Tree)(using Context): CompletionMap =
-      if qual.tpe.isExactlyNothing then
+      if qual.typeOpt.isExactlyNothing then
         Map.empty
       else
-        accessibleMembers(qual.tpe).groupByName
+        accessibleMembers(qual.typeOpt).groupByName
 
     /** Completions introduced by imports directly in this context.
      *  Completions from outer contexts are not included.
@@ -415,7 +415,7 @@ object Completion:
 
     /** Completions from implicit conversions including old style extensions using implicit classes */
     private def implicitConversionMemberCompletions(qual: Tree)(using Context): CompletionMap =
-      if qual.tpe.isExactlyNothing || qual.tpe.isNullType then
+      if qual.typeOpt.isExactlyNothing || qual.typeOpt.isNullType then
         Map.empty
       else
         implicitConversionTargets(qual)(using ctx.fresh.setExploreTyperState())
@@ -432,7 +432,7 @@ object Completion:
       def tryApplyingReceiverToExtension(termRef: TermRef): Option[SingleDenotation] =
         ctx.typer.tryApplyingExtensionMethod(termRef, qual)
           .map { tree =>
-            val tpe = asDefLikeType(tree.tpe.dealias)
+            val tpe = asDefLikeType(tree.typeOpt.dealias)
             termRef.denot.asSingleDenotation.mapInfo(_ => tpe)
           }
 
@@ -453,16 +453,16 @@ object Completion:
 
       // 1. The extension method is visible under a simple name, by being defined or inherited or imported in a scope enclosing the reference.
       val termCompleter = new Completer(Mode.Term, prefix, pos)
-      val extMethodsInScope = termCompleter.scopeCompletions.toList.flatMap {
-        case (name, denots) => denots.collect { case d: SymDenotation if d.isTerm => (d.termRef, name.asTermName) }
-      }
+      val extMethodsInScope = termCompleter.scopeCompletions.toList.flatMap:
+        case (name, denots) => denots.collect:
+          case d: SymDenotation if d.isTerm && d.termRef.symbol.is(Extension) => (d.termRef, name.asTermName)
 
       // 2. The extension method is a member of some given instance that is visible at the point of the reference.
       val givensInScope = ctx.implicits.eligible(defn.AnyType).map(_.implicitRef.underlyingRef)
       val extMethodsFromGivensInScope = extractMemberExtensionMethods(givensInScope)
 
       // 3. The reference is of the form r.m and the extension method is defined in the implicit scope of the type of r.
-      val implicitScopeCompanions = ctx.run.nn.implicitScope(qual.tpe).companionRefs.showAsList
+      val implicitScopeCompanions = ctx.run.nn.implicitScope(qual.typeOpt).companionRefs.showAsList
       val extMethodsFromImplicitScope = extractMemberExtensionMethods(implicitScopeCompanions)
 
       // 4. The reference is of the form r.m and the extension method is defined in some given instance in the implicit scope of the type of r.
@@ -472,7 +472,7 @@ object Completion:
       val availableExtMethods = extMethodsFromGivensInImplicitScope ++ extMethodsFromImplicitScope ++ extMethodsFromGivensInScope ++ extMethodsInScope
       val extMethodsWithAppliedReceiver = availableExtMethods.flatMap {
         case (termRef, termName) =>
-          if termRef.symbol.is(ExtensionMethod) && !qual.tpe.isBottomType then
+          if termRef.symbol.is(ExtensionMethod) && !qual.typeOpt.isBottomType then
             tryApplyingReceiverToExtension(termRef)
               .map(denot => termName -> denot)
           else None
@@ -551,21 +551,25 @@ object Completion:
      * @param qual The argument to which the implicit conversion should be applied.
      * @return The set of types after `qual` implicit conversion.
      */
-    private def implicitConversionTargets(qual: Tree)(using Context): Set[Type] = {
+    private def implicitConversionTargets(qual: Tree)(using Context): Set[Type] =
       val typer = ctx.typer
-      val conversions = new typer.ImplicitSearch(defn.AnyType, qual, pos.span).allImplicits
-      val targets = conversions.map(_.tree.tpe)
+      val targets = try {
+        val conversions = new typer.ImplicitSearch(defn.AnyType, qual, pos.span).allImplicits
+        conversions.map(_.tree.typeOpt)
+      } catch {
+        case _ =>
+          interactiv.println(i"implicit conversion targets failed: ${qual.show}")
+          Set.empty
+      }
 
       interactiv.println(i"implicit conversion targets considered: ${targets.toList}%, %")
       targets
-    }
 
     /** Filter for names that should appear when looking for completions. */
-    private object completionsFilter extends NameFilter {
+    private object completionsFilter extends NameFilter:
       def apply(pre: Type, name: Name)(using Context): Boolean =
         !name.isConstructorName && name.toTermName.info.kind == SimpleNameKind
       def isStable = true
-    }
 
     extension (denotations: Seq[SingleDenotation])
       def groupByName(using Context): CompletionMap = denotations.groupBy(_.name)

compiler/src/dotty/tools/dotc/interactive/Interactive.scala

@@ -282,12 +282,10 @@ object Interactive {
     case nested :: encl :: rest =>
       val outer = contextOfPath(encl :: rest)
       try encl match {
-        case tree @ PackageDef(pkg, stats) =>
-          assert(tree.symbol.exists)
+        case tree @ PackageDef(pkg, stats) if tree.symbol.exists =>
           if (nested `eq` pkg) outer
           else contextOfStat(stats, nested, pkg.symbol.moduleClass, outer.packageContext(tree, tree.symbol))
-        case tree: DefDef =>
-          assert(tree.symbol.exists)
+        case tree: DefDef if tree.symbol.exists =>
           val localCtx = outer.localContext(tree, tree.symbol).setNewScope
           for params <- tree.paramss; param <- params do localCtx.enter(param.symbol)
             // Note: this overapproximates visibility a bit, since value parameters are only visible

compiler/src/dotty/tools/dotc/interactive/InteractiveDriver.scala

@@ -277,7 +277,7 @@ class InteractiveDriver(val settings: List[String]) extends Driver {
         if (t.symbol.exists && t.hasType) {
           if (!t.symbol.isCompleted) t.symbol.info = UnspecifiedErrorType
           t.symbol.annotations.foreach { annot =>
-            /* In some cases annotations are are used on themself (possibly larger cycles).
+            /* In some cases annotations are used on themself (possibly larger cycles).
             *  This is the case with the java.lang.annotation.Target annotation, would end
             *  in an infinite loop while cleaning. The `seen` is added to ensure that those
             *  trees are not cleand twice.

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -3270,7 +3270,7 @@ object Parsers {
     /** ContextTypes   ::=  FunArgType {‘,’ FunArgType}
      */
     def contextTypes(paramOwner: ParamOwner, numLeadParams: Int, impliedMods: Modifiers): List[ValDef] =
-      val tps = commaSeparated(funArgType)
+      val tps = commaSeparated(() => paramTypeOf(toplevelTyp))
       var counter = numLeadParams
       def nextIdx = { counter += 1; counter }
       val paramFlags = if paramOwner.isClass then LocalParamAccessor else Param