Merge branch 'main' into fix-18763

Author: Alex1005a

.github/workflows/stdlib.yaml

@@ -10,7 +10,7 @@ permissions:
   contents: read
 
 jobs:
-  compile-nonbootstrapped:
+  scala-library-nonbootstrapped:
     runs-on: ubuntu-latest
     steps:
       - name: Git Checkout
@@ -27,8 +27,27 @@ jobs:
       - name: Compile `scala-library-nonbootstrapped`
         run: ./project/scripts/sbt scala-library-nonbootstrapped/compile
 
-  compile-bootstrapped:
+  scala3-library-nonbootstrapped:
     runs-on: ubuntu-latest
+    ##needs: [scala-library-nonbootstrapped] Add when we add support for caching here
+    steps:
+      - name: Git Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: 17
+          cache: 'sbt'
+
+      - uses: sbt/setup-sbt@v1
+      - name: Compile `scala3-library-nonbootstrapped`
+        run: ./project/scripts/sbt scala3-library-nonbootstrapped/compile
+
+  scala-library-bootstrapped:
+    runs-on: ubuntu-latest
+    needs  : [scala3-compiler-nonbootstrapped, scala3-sbt-bridge-nonbootstrapped, scala-library-nonbootstrapped, scala3-library-nonbootstrapped]
     steps:
       - name: Git Checkout
         uses: actions/checkout@v4
@@ -44,3 +63,122 @@ jobs:
       - name: Compile `scala-library-bootstrapped`
         run: ./project/scripts/sbt scala-library-bootstrapped/compile
 
+  scala3-library-bootstrapped:
+    runs-on: ubuntu-latest
+    ##needs: [scala-library-bootstrapped] Add when we add support for caching here
+    steps:
+      - name: Git Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: 17
+          cache: 'sbt'
+
+      - uses: sbt/setup-sbt@v1
+      - name: Compile `scala3-library-bootstrapped`
+        run: ./project/scripts/sbt scala3-library-bootstrapped-new/compile
+
+  tasty-core-nonbootstrapped:
+    runs-on: ubuntu-latest
+    ##needs: [scala3-library-nonbootstrapped] Add when we add support for caching here
+    steps:
+      - name: Git Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: 17
+          cache: 'sbt'
+      - uses: sbt/setup-sbt@v1
+      - name: Compile `tasty-core-nonbootstrapped`
+        run: ./project/scripts/sbt tasty-core-nonbootstrapped/compile
+
+  scala3-compiler-nonbootstrapped:
+    runs-on: ubuntu-latest
+    ##needs: [tasty-core-nonbootstrapped, scala3-library-nonbootstrapped] Add when we add support for caching here
+    steps:
+      - name: Git Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: 17
+          cache: 'sbt'
+      - uses: sbt/setup-sbt@v1
+      - name: Compile `scala3-compiler-nonbootstrapped`
+        run: ./project/scripts/sbt scala3-compiler-nonbootstrapped/compile
+
+  scala3-sbt-bridge-nonbootstrapped:
+    runs-on: ubuntu-latest
+    ##needs: [scala3-compiler-nonbootstrapped] Add when we add support for caching here
+    steps:
+      - name: Git Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: 17
+          cache: 'sbt'
+      - uses: sbt/setup-sbt@v1
+      - name: Compile `scala3-sbt-bridge-nonbootstrapped`
+        run: ./project/scripts/sbt scala3-sbt-bridge-nonbootstrapped/compile
+
+  tasty-core-bootstrapped:
+    runs-on: ubuntu-latest
+    ##needs: [scala3-library-bootstrapped] Add when we add support for caching here
+    steps:
+      - name: Git Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: 17
+          cache: 'sbt'
+      - uses: sbt/setup-sbt@v1
+      - name: Compile `tasty-core-bootstrapped`
+        run: ./project/scripts/sbt tasty-core-bootstrapped-new/compile
+
+  scala3-compiler-bootstrapped:
+    runs-on: ubuntu-latest
+    ##needs: [tasty-core-bootstrapped, scala3-library-bootstrapped] Add when we add support for caching here
+    steps:
+      - name: Git Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: 17
+          cache: 'sbt'
+      - uses: sbt/setup-sbt@v1
+      - name: Compile `scala3-compiler-bootstrapped`
+        run: ./project/scripts/sbt scala3-compiler-bootstrapped-new/compile
+
+  scala3-sbt-bridge-bootstrapped:
+    runs-on: ubuntu-latest
+    ##needs: [scala3-compiler-bootstrapped] Add when we add support for caching here
+    steps:
+      - name: Git Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: 17
+          cache: 'sbt'
+      - uses: sbt/setup-sbt@v1
+      - name: Compile `scala3-sbt-bridge-bootstrapped`
+        run: ./project/scripts/sbt scala3-sbt-bridge-bootstrapped/compile

.gitmodules

@@ -100,6 +100,7 @@
 [submodule "community-build/community-projects/scala-parallel-collections"]
 	path = community-build/community-projects/scala-parallel-collections
 	url = https://github.com/dotty-staging/scala-parallel-collections.git
+	branch = serialisation-stability-fix
 [submodule "community-build/community-projects/scala-collection-compat"]
 	path = community-build/community-projects/scala-collection-compat
 	url = https://github.com/dotty-staging/scala-collection-compat.git

build.sbt

@@ -1,14 +1,22 @@
 val scala3 = Build.scala3
+val `scala3-nonbootstrapped` = Build.`scala3-nonbootstrapped`
 val `scala3-bootstrapped` = Build.`scala3-bootstrapped`
+val `scala3-bootstrapped-new` = Build.`scala3-bootstrapped-new`
 val `scala3-interfaces` = Build.`scala3-interfaces`
 val `scala3-compiler` = Build.`scala3-compiler`
+val `scala3-compiler-nonbootstrapped` = Build.`scala3-compiler-nonbootstrapped`
+val `scala3-compiler-bootstrapped-new` = Build.`scala3-compiler-bootstrapped-new`
 val `scala3-compiler-bootstrapped` = Build.`scala3-compiler-bootstrapped`
 val `scala-library-nonbootstrapped` = Build.`scala-library-nonbootstrapped`
+val `scala3-library-nonbootstrapped` = Build.`scala3-library-nonbootstrapped`
 val `scala-library-bootstrapped` = Build.`scala-library-bootstrapped`
+val `scala3-library-bootstrapped-new` = Build.`scala3-library-bootstrapped-new`
 val `scala3-library` = Build.`scala3-library`
 val `scala3-library-bootstrapped` = Build.`scala3-library-bootstrapped`
 val `scala3-library-bootstrappedJS` = Build.`scala3-library-bootstrappedJS`
 val `scala3-sbt-bridge` = Build.`scala3-sbt-bridge`
+val `scala3-sbt-bridge-bootstrapped` = Build.`scala3-sbt-bridge-bootstrapped`
+val `scala3-sbt-bridge-nonbootstrapped` = Build.`scala3-sbt-bridge-nonbootstrapped`
 val `scala3-sbt-bridge-tests` = Build.`scala3-sbt-bridge-tests`
 val `scala3-staging` = Build.`scala3-staging`
 val `scala3-tasty-inspector` = Build.`scala3-tasty-inspector`
@@ -21,6 +29,8 @@ val `scala2-library-tasty` = Build.`scala2-library-tasty`
 val `scala2-library-cc` = Build.`scala2-library-cc`
 val `scala2-library-cc-tasty` = Build.`scala2-library-cc-tasty`
 val `tasty-core` = Build.`tasty-core`
+val `tasty-core-nonbootstrapped` = Build.`tasty-core-nonbootstrapped`
+val `tasty-core-bootstrapped-new` = Build.`tasty-core-bootstrapped-new`
 val `tasty-core-bootstrapped` = Build.`tasty-core-bootstrapped`
 val `tasty-core-scala2` = Build.`tasty-core-scala2`
 val scaladoc = Build.scaladoc

community-build/community-projects/scala-parallel-collections

@@ -31,6 +31,7 @@ import dotty.tools.dotc.core.Types.*
 import dotty.tools.dotc.core.TypeErasure
 import dotty.tools.dotc.transform.GenericSignatures
 import dotty.tools.dotc.transform.ElimErasedValueType
+import dotty.tools.dotc.transform.Mixin
 import dotty.tools.io.AbstractFile
 import dotty.tools.dotc.report
 
@@ -395,12 +396,20 @@ trait BCodeHelpers extends BCodeIdiomatic {
      */
     def getGenericSignature(sym: Symbol, owner: Symbol): String = {
       atPhase(erasurePhase) {
-        val memberTpe =
+        def computeMemberTpe(): Type =
           if (sym.is(Method)) sym.denot.info
           else if sym.denot.validFor.phaseId > erasurePhase.id && sym.isField && sym.getter.exists then
             // Memoization field of getter entered after erasure, see run/i17069 for an example
             sym.getter.denot.info.resultType
           else owner.denot.thisType.memberInfo(sym)
+
+        val memberTpe = if sym.is(MixedIn) then
+          mixinPhase.asInstanceOf[Mixin].mixinForwarderGenericInfos.get(sym) match
+            case Some(genericInfo) => genericInfo
+            case none              => computeMemberTpe()
+        else
+          computeMemberTpe()
+
         getGenericSignatureHelper(sym, owner, memberTpe).orNull
       }
     }
@@ -491,7 +500,7 @@ trait BCodeHelpers extends BCodeIdiomatic {
       report.debuglog(s"Potentially conflicting names for forwarders: $conflictingNames")
 
       for (m0 <- sortedMembersBasedOnFlags(moduleClass.info, required = Method, excluded = ExcludedForwarder)) {
-        val m = if (m0.is(Bridge)) m0.nextOverriddenSymbol else m0
+        val m = if (m0.isOneOf(Bridge | MixedIn)) m0.nextOverriddenSymbol else m0
         if (m == NoSymbol)
           report.log(s"$m0 is a bridge method that overrides nothing, something went wrong in a previous phase.")
         else if (m.isType || m.is(Deferred) || (m.owner eq defn.ObjectClass) || m.isConstructor || m.name.is(ExpandedName))
@@ -507,10 +516,7 @@ trait BCodeHelpers extends BCodeIdiomatic {
           // we generate ACC_SYNTHETIC forwarders so Java compilers ignore them.
           val isSynthetic =
             m0.name.is(NameKinds.SyntheticSetterName) ||
-            // Only hide bridges generated at Erasure, mixin forwarders are also
-            // marked as bridge but shouldn't be hidden since they don't have a
-            // non-bridge overload.
-            m0.is(Bridge) && m0.initial.validFor.firstPhaseId == erasurePhase.next.id
+            m0.is(Bridge)
           addForwarder(jclass, moduleClass, m, isSynthetic)
         }
       }

compiler/src/dotty/tools/backend/jvm/BCodeHelpers.scala

@@ -299,7 +299,7 @@ class BTypesFromSymbols[I <: DottyBackendInterface](val int: I, val frontendAcce
         // illegal combination of modifiers at the bytecode level so
         // suppress final if abstract if present.
         && !sym.isOneOf(AbstractOrTrait)
-        //  Mixin forwarders are bridges and can be final, but final bridges confuse some frameworks
+        // Bridges can be final, but final bridges confuse some frameworks
         && !sym.is(Bridge), ACC_FINAL)
       .addFlagIf(sym.isStaticMember, ACC_STATIC)
       .addFlagIf(sym.is(Bridge), ACC_BRIDGE | ACC_SYNTHETIC)

compiler/src/dotty/tools/backend/jvm/BTypesFromSymbols.scala

@@ -2321,10 +2321,6 @@ object desugar {
             Annotated(
               AppliedTypeTree(ref(defn.SeqType), t),
               New(ref(defn.RepeatedAnnot.typeRef), Nil :: Nil))
-        else if op.name == nme.CC_REACH then
-          Annotated(t, New(ref(defn.ReachCapabilityAnnot.typeRef), Nil :: Nil))
-        else if op.name == nme.CC_READONLY then
-          Annotated(t, New(ref(defn.ReadOnlyCapabilityAnnot.typeRef), Nil :: Nil))
         else
           assert(ctx.mode.isExpr || ctx.reporter.errorsReported || ctx.mode.is(Mode.Interactive), ctx.mode)
           Select(t, op.name)

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

@@ -94,17 +94,29 @@ object NavigateAST {
       * When choosing better fit we compare spans. If candidate span has starting or ending point inside (exclusive)
       * current best fit it is selected as new best fit. This means that same spans are failing the first predicate.
       *
-      * In case when spans start and end at same offsets we prefer non synthethic one.
+      * In case when spans start and end at same offsets we prefer non synthethic one,
+      * and then one with better point (see isBetterPoint below).
       */
     def isBetterFit(currentBest: List[Positioned], candidate: List[Positioned]): Boolean =
       if currentBest.isEmpty && candidate.nonEmpty then true
       else if currentBest.nonEmpty && candidate.nonEmpty then
         val bestSpan = currentBest.head.span
         val candidateSpan = candidate.head.span
 
-        bestSpan != candidateSpan &&
-          envelops(bestSpan, candidateSpan) ||
-          bestSpan.contains(candidateSpan) && bestSpan.isSynthetic && !candidateSpan.isSynthetic
+        def isBetterPoint =
+          // Given two spans with same end points,
+          // we compare their points in relation to the point we are looking for (span.point)
+          // The candidate (candidateSpan.point) is better than what we have so far (bestSpan.point), when:
+          // 1) candidate is closer to target from the right
+          span.point <= candidateSpan.point && candidateSpan.point < bestSpan.point
+          // 2) candidate is closer to target from the left
+          || bestSpan.point < candidateSpan.point && candidateSpan.point <= span.point
+          // 3) candidate is to on the left side of target, and best so far is on the right
+          || candidateSpan.point <= span.point && span.point < bestSpan.point
+
+        bestSpan != candidateSpan && envelops(bestSpan, candidateSpan)
+        || bestSpan.contains(candidateSpan) && bestSpan.isSynthetic && !candidateSpan.isSynthetic
+        || candidateSpan.start == bestSpan.start && candidateSpan.end == bestSpan.end && isBetterPoint
       else false
 
     def isRecoveryTree(sel: untpd.Select): Boolean =

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

@@ -550,6 +550,15 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
       annot.putAttachment(RetainsAnnot, ())
     Annotated(parent, annot)
 
+  def makeReachAnnot()(using Context): Tree =
+    New(ref(defn.ReachCapabilityAnnot.typeRef), Nil :: Nil)
+
+  def makeReadOnlyAnnot()(using Context): Tree =
+    New(ref(defn.ReadOnlyCapabilityAnnot.typeRef), Nil :: Nil)
+
+  def makeOnlyAnnot(qid: Tree)(using Context) =
+    New(AppliedTypeTree(ref(defn.OnlyCapabilityAnnot.typeRef), qid :: Nil), Nil :: Nil)
+
   def makeConstructor(tparams: List[TypeDef], vparamss: List[List[ValDef]], rhs: Tree = EmptyTree)(using Context): DefDef =
     DefDef(nme.CONSTRUCTOR, joinParams(tparams, vparamss), TypeTree(), rhs)
 

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

@@ -81,6 +81,16 @@ class CCState:
   def start(): Unit =
     iterCount = 1
 
+  private var mySepCheck = false
+
+  /** Are we currently running separation checks? */
+  def isSepCheck = mySepCheck
+
+  def inSepCheck(op: => Unit): Unit =
+    val saved = mySepCheck
+    mySepCheck = true
+    try op finally mySepCheck = saved
+
   // ------ Global counters -----------------------
 
   /** Next CaptureSet.Var id */