Merge branch 'scala:main' into init-global-warning

Author: JasonH53

.github/workflows/lts-backport.yaml

@@ -16,7 +16,7 @@ jobs:
         with:
           fetch-depth: 0
       - uses: coursier/cache-action@v6
-      - uses: VirtusLab/scala-cli-setup@v1.8.1
+      - uses: VirtusLab/scala-cli-setup@v1.8.3
       - run: scala-cli ./project/scripts/addToBackportingProject.scala -- ${{ github.sha }}
         env:
           GRAPHQL_API_TOKEN: ${{ secrets.GRAPHQL_API_TOKEN }}

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

@@ -92,7 +92,8 @@ class Compiler {
          new ExplicitSelf,           // Make references to non-trivial self types explicit as casts
          new StringInterpolatorOpt,  // Optimizes raw and s and f string interpolators by rewriting them to string concatenations or formats
          new DropBreaks) ::          // Optimize local Break throws by rewriting them
-    List(new UninitializedDefs,      // Replaces `compiletime.uninitialized` by `_`
+    List(new PruneErasedDefs,        // Make erased symbols private
+         new UninitializedDefs,      // Replaces `compiletime.uninitialized` by `_`
          new InlinePatterns,         // Remove placeholders of inlined patterns
          new VCInlineMethods,        // Inlines calls to value class methods
          new SeqLiterals,            // Express vararg arguments as arrays

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -1719,7 +1719,7 @@ object desugar {
    */
   def tuple(tree: Tuple, pt: Type)(using Context): Tree =
     var elems = checkWellFormedTupleElems(tree.trees)
-    if ctx.mode.is(Mode.Pattern) then elems = adaptPatternArgs(elems, pt)
+    if ctx.mode.is(Mode.Pattern) then elems = adaptPatternArgs(elems, pt, tree.srcPos)
     val elemValues = elems.mapConserve(stripNamedArg)
     val tup =
       val arity = elems.length
@@ -1759,25 +1759,31 @@ object desugar {
    *   - If `elems` are named pattern elements, rearrange them to match `pt`.
    *     This requires all names in `elems` to be also present in `pt`.
    */
-  def adaptPatternArgs(elems: List[Tree], pt: Type)(using Context): List[Tree] =
+  def adaptPatternArgs(elems: List[Tree], pt: Type, pos: SrcPos)(using Context): List[Tree] =
 
     def reorderedNamedArgs(wildcardSpan: Span): List[untpd.Tree] =
-      var selNames = pt.namedTupleElementTypes(false).map(_(0))
-      if selNames.isEmpty && pt.classSymbol.is(CaseClass) then
-        selNames = pt.classSymbol.caseAccessors.map(_.name.asTermName)
-      val nameToIdx = selNames.zipWithIndex.toMap
-      val reordered = Array.fill[untpd.Tree](selNames.length):
-        untpd.Ident(nme.WILDCARD).withSpan(wildcardSpan)
-      for case arg @ NamedArg(name: TermName, _) <- elems do
-        nameToIdx.get(name) match
-          case Some(idx) =>
-            if reordered(idx).isInstanceOf[Ident] then
-              reordered(idx) = arg
-            else
-              report.error(em"Duplicate named pattern", arg.srcPos)
-          case _ =>
-            report.error(em"No element named `$name` is defined in selector type $pt", arg.srcPos)
-      reordered.toList
+      inline def isCaseClass = pt.classSymbol.is(CaseClass) && !defn.isTupleClass(pt.classSymbol)
+      if !isCaseClass && !pt.isNamedTupleType then
+        report.error(NamedPatternNotApplicable(pt), pos)
+        Nil
+      else
+        var selNames = pt.namedTupleElementTypes(false).map(_(0))
+        if isCaseClass && selNames.isEmpty then
+          selNames = pt.classSymbol.caseAccessors.map(_.name.asTermName)
+        val nameToIdx = selNames.zipWithIndex.toMap
+        val reordered = Array.fill[untpd.Tree](selNames.length):
+          untpd.Ident(nme.WILDCARD).withSpan(wildcardSpan)
+        for case arg @ NamedArg(name: TermName, _) <- elems do
+          nameToIdx.get(name) match
+            case Some(idx) =>
+              if reordered(idx).isInstanceOf[Ident] then
+                reordered(idx) = arg
+              else
+                report.error(em"Duplicate named pattern", arg.srcPos)
+            case _ =>
+              report.error(em"No element named `$name` is defined in selector type $pt", arg.srcPos)
+        reordered.toList
+      end if
 
     elems match
       case (first @ NamedArg(_, _)) :: _ => reorderedNamedArgs(first.span.startPos)

compiler/src/dotty/tools/dotc/ast/NavigateAST.scala

@@ -141,7 +141,9 @@ object NavigateAST {
           case _ =>
         val iterator = p match
           case defdef: DefTree[?] =>
-            p.productIterator ++ defdef.mods.productIterator
+            val mods = defdef.mods
+            val annotations = defdef.symbol.annotations.filter(_.tree.span.contains(span)).map(_.tree)
+            p.productIterator ++ annotations ++ mods.productIterator
           case _ =>
             p.productIterator
         childPath(iterator, p :: path)

compiler/src/dotty/tools/dotc/ast/TreeTypeMap.scala

@@ -225,6 +225,11 @@ class TreeTypeMap(
         val tmap1 = tmap.withMappedSyms(
           origCls(cls).typeParams ::: origDcls,
           cls.typeParams ::: mappedDcls)
+        mapped.foreach { sym =>
+          // outer Symbols can reference nested ones in info,
+          // so we remap that once again with the updated TreeTypeMap
+          sym.info = tmap1.mapType(sym.info)
+        }
         origDcls.lazyZip(mappedDcls).foreach(cls.asClass.replace)
         tmap1
       }

compiler/src/dotty/tools/dotc/ast/Trees.scala

@@ -512,9 +512,9 @@ object Trees {
 
   /** The kind of application */
   enum ApplyKind:
-    case Regular      // r.f(x)
-    case Using        // r.f(using x)
-    case InfixTuple   // r f (x1, ..., xN) where N != 1;  needs to be treated specially for an error message in typedApply
+    case Regular    // r.f(x)
+    case Using      // r.f(using x)
+    case InfixTuple // r f (x1, ..., xN) where N != 1; needs to be treated specially for an error message in typedApply
 
   /** fun(args) */
   case class Apply[+T <: Untyped] private[ast] (fun: Tree[T], args: List[Tree[T]])(implicit @constructorOnly src: SourceFile)

compiler/src/dotty/tools/dotc/cc/Capability.scala

@@ -21,7 +21,7 @@ import annotation.constructorOnly
 import ast.tpd
 import printing.{Printer, Showable}
 import printing.Texts.Text
-import reporting.Message
+import reporting.{Message, trace}
 import NameOps.isImpureFunction
 import annotation.internal.sharable
 
@@ -693,7 +693,7 @@ object Capabilities:
     thisMap =>
 
     override def apply(t: Type) =
-      if variance <= 0 then t
+      if variance < 0 then t
       else t match
         case t @ CapturingType(_, _) =>
           mapOver(t)
@@ -703,6 +703,8 @@ object Capabilities:
             this(CapturingType(parent1, ann.tree.toCaptureSet))
           else
             t.derivedAnnotatedType(parent1, ann)
+        case defn.RefinedFunctionOf(_) =>
+          t  // stop at dependent function types
         case _ =>
           mapFollowingAliases(t)
 
@@ -784,7 +786,7 @@ object Capabilities:
     abstract class CapMap extends BiTypeMap:
       override def mapOver(t: Type): Type = t match
         case t @ FunctionOrMethod(args, res) if variance > 0 && !t.isAliasFun =>
-          t // `t` should be mapped in this case by a different call to `mapCap`.
+          t // `t` should be mapped in this case by a different call to `toResult`. See [[toResultInResults]].
         case t: (LazyRef | TypeVar) =>
           mapConserveSuper(t)
         case _ =>
@@ -849,7 +851,8 @@ object Capabilities:
   end toResult
 
   /** Map global roots in function results to result roots. Also,
-   *  map roots in the types of parameterless def methods.
+   *  map roots in the types of def methods that are parameterless
+   *  or have only type parameters.
    */
   def toResultInResults(sym: Symbol, fail: Message => Unit, keepAliases: Boolean = false)(tp: Type)(using Context): Type =
     val m = new TypeMap with FollowAliasesMap:
@@ -878,8 +881,19 @@ object Capabilities:
             throw ex
     m(tp) match
       case tp1: ExprType if sym.is(Method, butNot = Accessor) =>
+        // Map the result of parameterless `def` methods.
         tp1.derivedExprType(toResult(tp1.resType, tp1, fail))
+      case tp1: PolyType if !tp1.resType.isInstanceOf[MethodicType] =>
+        // Map also the result type of method with only type parameters.
+        // This way, the `^` in the following method will be mapped to a `ResultCap`:
+        // ```
+        // object Buffer:
+        //   def empty[T]: Buffer[T]^
+        // ```
+        // This is more desirable than interpreting `^` as a `Fresh` at the level of `Buffer.empty`
+        // in most cases.
+        tp1.derivedLambdaType(resType = toResult(tp1.resType, tp1, fail))
       case tp1 => tp1
   end toResultInResults
 
-end Capabilities
+end Capabilities

compiler/src/dotty/tools/dotc/cc/CaptureOps.scala

@@ -203,6 +203,39 @@ extension (tp: Type)
     case _ =>
       tp
 
+  /** If `tp` is an unboxed capturing type or a function returning an unboxed capturing type,
+   *  convert it to be boxed.
+   */
+  def boxDeeply(using Context): Type =
+    def recur(tp: Type): Type = tp.dealiasKeepAnnotsAndOpaques match
+      case tp @ CapturingType(parent, refs) =>
+        if tp.isBoxed || parent.derivesFrom(defn.Caps_CapSet) then tp
+        else tp.boxed
+      case tp @ AnnotatedType(parent, ann) =>
+        if ann.symbol.isRetains && !parent.derivesFrom(defn.Caps_CapSet)
+        then CapturingType(parent, ann.tree.toCaptureSet, boxed = true)
+        else tp.derivedAnnotatedType(parent.boxDeeply, ann)
+      case tp: (Capability & SingletonType) if tp.isTrackableRef && !tp.isAlwaysPure =>
+        recur(CapturingType(tp, CaptureSet(tp)))
+      case tp1 @ AppliedType(tycon, args) if defn.isNonRefinedFunction(tp1) =>
+        val res = args.last
+        val boxedRes = recur(res)
+        if boxedRes eq res then tp
+        else tp1.derivedAppliedType(tycon, args.init :+ boxedRes)
+      case tp1 @ defn.RefinedFunctionOf(rinfo: MethodType) =>
+        val boxedRinfo = recur(rinfo)
+        if boxedRinfo eq rinfo then tp
+        else boxedRinfo.toFunctionType(alwaysDependent = true)
+      case tp1: MethodOrPoly =>
+        val res = tp1.resType
+        val boxedRes = recur(res)
+        if boxedRes eq res then tp
+        else tp1.derivedLambdaType(resType = boxedRes)
+      case _ => tp
+    tp match
+      case tp: MethodOrPoly => tp // don't box results of methods outside refinements
+      case _ => recur(tp)
+
   /** The capture set consisting of all top-level captures of `tp` that appear under a box.
    *  Unlike for `boxed` this also considers parents of capture types, unions and
    *  intersections, and type proxies other than abstract types.
@@ -621,9 +654,12 @@ object ContainsImpl:
 object ContainsParam:
   def unapply(sym: Symbol)(using Context): Option[(TypeRef, Capability)] =
     sym.info.dealias match
-      case AppliedType(tycon, (cs: TypeRef) :: (ref: Capability) :: Nil)
+      case AppliedType(tycon, (cs: TypeRef) :: arg2 :: Nil)
       if tycon.typeSymbol == defn.Caps_ContainsTrait
-          && cs.typeSymbol.isAbstractOrParamType => Some((cs, ref))
+          && cs.typeSymbol.isAbstractOrParamType =>
+        arg2.stripCapturing match // ref.type was converted to box ref.type^{ref} by boxing
+          case ref: Capability => Some((cs, ref))
+          case _ => None
       case _ => None
 
 /** A class encapsulating the assumulator logic needed for `CaptureSet.ofTypeDeeply`

compiler/src/dotty/tools/dotc/cc/CaptureSet.scala

@@ -14,7 +14,6 @@ import printing.{Showable, Printer}
 import printing.Texts.*
 import util.{SimpleIdentitySet, Property}
 import typer.ErrorReporting.Addenda
-import util.common.alwaysTrue
 import scala.collection.{mutable, immutable}
 import TypeComparer.ErrorNote
 import CCState.*

compiler/src/dotty/tools/dotc/cc/CheckCaptures.scala

@@ -684,6 +684,7 @@ class CheckCaptures extends Recheck, SymTransformer:
       //   - the selection is either a trackable capture reference or a pure type
       if noWiden(selType, pt)
           || qualType.isBoxedCapturing
+          || selType.isBoxedCapturing
           || selWiden.isBoxedCapturing
           || selType.isTrackableRef
           || selWiden.captureSet.isAlwaysEmpty
@@ -882,7 +883,7 @@ class CheckCaptures extends Recheck, SymTransformer:
         val cs = csArg.nuType.captureSet
         val ref = refArg.nuType
         capt.println(i"check contains $cs , $ref")
-        ref match
+        ref.stripCapturing match
           case ref: Capability if ref.isTracked =>
             checkElem(ref, cs, tree.srcPos)
           case _ =>
@@ -1677,7 +1678,7 @@ class CheckCaptures extends Recheck, SymTransformer:
       actual.isSingleton
       && expected.match
           case expected: PathSelectionProto => !expected.sym.isOneOf(UnstableValueFlags)
-          case _ => expected.isSingleton || expected == LhsProto
+          case _ => expected.stripCapturing.isSingleton || expected == LhsProto
 
     /** Adapt `actual` type to `expected` type. This involves:
      *   - narrow toplevel captures of `x`'s underlying type to `{x}` according to CC's VAR rule
@@ -1686,7 +1687,14 @@ class CheckCaptures extends Recheck, SymTransformer:
      */
     def adapt(actual: Type, expected: Type, tree: Tree)(using Context): Type =
       if noWiden(actual, expected) then
-        actual
+        expected match
+          case expected @ CapturingType(_, _) if expected.isBoxed =>
+            // actual is a singleton type and expected is of the form box x.type^cs.
+            // Convert actual to the same form.
+            actual.boxDeeply
+              .showing(i"adapt single $actual / $result vs $expected", capt)
+          case _ =>
+            actual
       else
         // Compute the widened type. Drop `@use` and `@consume` annotations from the type,
         // since they obscures the capturing type.