Merge remote-tracking branch 'origin/main' into sbt-1.1

Author: SethTisue

.github/workflows/build-msi.yml

@@ -14,8 +14,8 @@ on:
   workflow_call:
 
 env:
-  # NECESSARY FLAG TO CORRECTLY CONFIGURE THE VERSION FOR SCALA
-  RELEASEBUILD: yes
+  # Release only happends when triggering CI by pushing tag
+  RELEASEBUILD: ${{ startsWith(github.event.ref, 'refs/tags/') && 'yes' || 'no' }}
 
 jobs:
   build:

.github/workflows/ci.yaml

@@ -737,7 +737,7 @@ jobs:
         - ${{ github.workspace }}/../../cache/sbt:/root/.sbt
         - ${{ github.workspace }}/../../cache/ivy:/root/.ivy2/cache
         - ${{ github.workspace }}/../../cache/general:/root/.cache
-    needs: [test_non_bootstrapped, test, mima, community_build_a, community_build_b, community_build_c, test_sbt, test_java8, build-sdk-package]
+    needs: [test_non_bootstrapped, test, mima, community_build_a, community_build_b, community_build_c, test_sbt, test_java8, build-sdk-package, build-msi-package]
     if: "github.event_name == 'push'
          && startsWith(github.event.ref, 'refs/tags/')"
 
@@ -816,6 +816,18 @@ jobs:
           prepareSDK "-x86_64-apple-darwin"  "dist-mac-x86_64"    "./dist/mac-x86_64/"
           prepareSDK "-x86_64-pc-win32"      "dist-win-x86_64"    "./dist/win-x86_64/"
 
+      - name: Download MSI package
+        uses: actions/download-artifact@v4
+        with:
+          name: scala.msi
+          path: .
+      - name: Prepare MSI package
+        shell: bash
+        run: | 
+          msiInstaller="scala3-${{ env.RELEASE_TAG }}.msi"
+          mv scala.msi "${msiInstaller}"
+          sha256sum "${msiInstaller}" > "${msiInstaller}.sha256"
+
       # Create the GitHub release
       - name: Create GitHub Release
         id: create_gh_release
@@ -829,10 +841,10 @@ jobs:
           draft: true
           prerelease: ${{ contains(env.RELEASE_TAG, '-') }}
 
-      # The following steps are generated using template:
-      # def template(distribution: String, suffix: String) =
-      #   def upload(kind: String, path: String, contentType: String) =
-      #     s"""- name: Upload $kind to GitHub Release ($distribution)
+      # The following upload steps are generated using template:
+      # val baseFileName = "scala3-${{ env.RELEASE_TAG }}"
+      # def upload(kind: String, path: String, contentType: String, distribution: String) =
+      #   s"""- name: Upload $kind to GitHub Release ($distribution)
       #         uses: actions/upload-release-asset@v1
       #         env:
       #           GITHUB_TOKEN: $${{ secrets.GITHUB_TOKEN }}
@@ -841,24 +853,33 @@ jobs:
       #           asset_path: ./${path}
       #           asset_name: ${path}
       #           asset_content_type: ${contentType}"""
-      #   val filename = s"scala3-$${{ env.RELEASE_TAG }}${suffix}"
+      # def uploadSDK(distribution: String, suffix: String) =
+      #   val filename = s"${baseFileName}${suffix}"
       #   s"""
       #       # $distribution
-      #       ${upload("zip archive", s"$filename.zip", "application/zip")}
-      #       ${upload("zip archive SHA", s"$filename.zip.sha256", "text/plain")}
-      #       ${upload("tar.gz archive", s"$filename.tar.gz", "application/gzip")}
-      #       ${upload("tar.gz archive SHA", s"$filename.tar.gz.sha256", "text/plain")}
+      #       ${upload("zip archive", s"$filename.zip", "application/zip", distribution)}
+      #       ${upload("zip archive SHA", s"$filename.zip.sha256", "text/plain", distribution)}
+      #       ${upload("tar.gz archive", s"$filename.tar.gz", "application/gzip", distribution)}
+      #       ${upload("tar.gz archive SHA", s"$filename.tar.gz.sha256", "text/plain", distribution)}
+      # """
+      # def uploadMSI() = 
+      #     val distribution = "Windows x86_64 MSI"
+      #     s"""
+      #       # $distribution
+      #       ${upload(".msi file", s"${baseFileName}.msi", "application/x-msi", distribution)}
+      #       ${upload(".msi file SHA", s"${baseFileName}.msi.sha256", "text/plain", distribution)}
       # """
-
       # @main def gen =
       #   Seq(
-      #     template("Universal", ""),
-      #     template("Linux x86-64", "-x86_64-pc-linux"),
-      #     template("Linux aarch64", "-aarch64-pc-linux"),
-      #     template("Mac x86-64", "-x86_64-apple-darwin"),
-      #     template("Mac aarch64", "-aarch64-apple-darwin"),
-      #     template("Windows x86_64", "-x86_64-pc-win32")
+      #     uploadSDK("Universal", ""),
+      #     uploadSDK("Linux x86-64", "-x86_64-pc-linux"),
+      #     uploadSDK("Linux aarch64", "-aarch64-pc-linux"),
+      #     uploadSDK("Mac x86-64", "-x86_64-apple-darwin"),
+      #     uploadSDK("Mac aarch64", "-aarch64-apple-darwin"),
+      #     uploadSDK("Windows x86_64", "-x86_64-pc-win32"),
+      #     uploadMSI()
       #   ).foreach(println)
+
       # Universal
       - name: Upload zip archive to GitHub Release (Universal)
         uses: actions/upload-release-asset@v1
@@ -1092,8 +1113,29 @@ jobs:
           asset_name: scala3-${{ env.RELEASE_TAG }}-x86_64-pc-win32.tar.gz.sha256
           asset_content_type: text/plain
 
+
+      # Windows x86_64 MSI
+      - name: Upload .msi file to GitHub Release (Windows x86_64 MSI)
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_gh_release.outputs.upload_url }}
+          asset_path: ./scala3-${{ env.RELEASE_TAG }}.msi
+          asset_name: scala3-${{ env.RELEASE_TAG }}.msi
+          asset_content_type: application/x-msi
+      - name: Upload .msi file SHA to GitHub Release (Windows x86_64 MSI)
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.create_gh_release.outputs.upload_url }}
+          asset_path: ./scala3-${{ env.RELEASE_TAG }}.msi.sha256
+          asset_name: scala3-${{ env.RELEASE_TAG }}.msi.sha256
+          asset_content_type: text/plain
+
       - name: Publish Release
-        run: ./project/scripts/sbtPublish ";project scala3-bootstrapped ;publishSigned ;sonatypeBundleRelease"
+        run: ./project/scripts/sbtPublish ";project scala3-bootstrapped ;publishSigned ;sonatypeBundleUpload"
 
 
   open_issue_on_failure:
@@ -1118,14 +1160,16 @@ jobs:
 
   build-msi-package:
     uses: ./.github/workflows/build-msi.yml
-    if  : github.event_name == 'pull_request' && contains(github.event.pull_request.body, '[test_msi]')
+    if  :
+      (github.event_name == 'pull_request' && contains(github.event.pull_request.body, '[test_msi]')) ||
+      (github.event_name == 'push' && startsWith(github.event.ref, 'refs/tags/'))
 
   test-msi-package:
     uses: ./.github/workflows/test-msi.yml
     needs: [build-msi-package]
     with:
       # Ensure that version starts with prefix 3.
-      # In the future it can be adapted to compare with with git tag or version set in the build.s 
+      # In the future it can be adapted to compare with with git tag or version set in the project/Build.scala
       version: "3."
       java-version: 8
 

.github/workflows/publish-sdkman.yml

@@ -46,7 +46,7 @@ jobs:
           - platform: WINDOWS_64
             archive : 'scala3-${{ inputs.version }}-x86_64-pc-win32.zip'
     steps:
-      - uses: hamzaremmal/sdkman-release-action@1f2d4209b4f5a38721d4ae20014ea8e1689d869e
+      - uses: sdkman/sdkman-release-action@1f2d4209b4f5a38721d4ae20014ea8e1689d869e
         with:
           CONSUMER-KEY   : ${{ secrets.CONSUMER-KEY }}
           CONSUMER-TOKEN : ${{ secrets.CONSUMER-TOKEN }}
@@ -59,7 +59,7 @@ jobs:
     runs-on: ubuntu-latest
     needs: publish
     steps:
-      - uses: hamzaremmal/sdkman-default-action@b3f991bd109e40155af1b13a4c6fc8e8ccada65e
+      - uses: sdkman/sdkman-default-action@b3f991bd109e40155af1b13a4c6fc8e8ccada65e
         with:
           CONSUMER-KEY   : ${{ secrets.CONSUMER-KEY }}
           CONSUMER-TOKEN : ${{ secrets.CONSUMER-TOKEN }}

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

@@ -142,9 +142,9 @@ trait TreeInfo[T <: Untyped] { self: Trees.Instance[T] =>
 
   /** All term arguments of an application in a single flattened list */
   def allTermArguments(tree: Tree): List[Tree] = unsplice(tree) match {
-    case Apply(fn, args) => allArguments(fn) ::: args
-    case TypeApply(fn, args) => allArguments(fn)
-    case Block(_, expr) => allArguments(expr)
+    case Apply(fn, args) => allTermArguments(fn) ::: args
+    case TypeApply(fn, args) => allTermArguments(fn)
+    case Block(_, expr) => allTermArguments(expr)
     case _ => Nil
   }
 

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

@@ -524,8 +524,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def makeRetaining(parent: Tree, refs: List[Tree], annotName: TypeName)(using Context): Annotated =
     Annotated(parent, New(scalaAnnotationDot(annotName), List(refs)))
 
-  def makeCapsOf(id: Ident)(using Context): Tree =
-    TypeApply(Select(scalaDot(nme.caps), nme.capsOf), id :: Nil)
+  def makeCapsOf(tp: RefTree)(using Context): Tree =
+    TypeApply(Select(scalaDot(nme.caps), nme.capsOf), tp :: Nil)
 
   def makeCapsBound()(using Context): Tree =
     makeRetaining(

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

@@ -194,7 +194,7 @@ extension (tp: Type)
       true
     case tp: TermRef =>
       ((tp.prefix eq NoPrefix)
-      || tp.symbol.is(ParamAccessor) && tp.prefix.isThisTypeOf(tp.symbol.owner)
+      || tp.symbol.isField && !tp.symbol.isStatic && tp.prefix.isTrackableRef
       || tp.isRootCapability
       ) && !tp.symbol.isOneOf(UnstableValueFlags)
     case tp: TypeRef =>

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

@@ -61,18 +61,19 @@ trait CaptureRef extends TypeProxy, ValueType:
     case tp: TermParamRef => tp.underlying.derivesFrom(defn.Caps_Exists)
     case _ => false
 
-  /** Normalize reference so that it can be compared with `eq` for equality */
-  final def normalizedRef(using Context): CaptureRef = this match
-    case tp @ AnnotatedType(parent: CaptureRef, annot) if tp.isTrackableRef =>
-      tp.derivedAnnotatedType(parent.normalizedRef, annot)
-    case tp: TermRef if tp.isTrackableRef =>
-      tp.symbol.termRef
-    case _ => this
+  // With the support of pathes, we don't need to normalize the `TermRef`s anymore.
+  // /** Normalize reference so that it can be compared with `eq` for equality */
+  // final def normalizedRef(using Context): CaptureRef = this match
+  //   case tp @ AnnotatedType(parent: CaptureRef, annot) if tp.isTrackableRef =>
+  //     tp.derivedAnnotatedType(parent.normalizedRef, annot)
+  //   case tp: TermRef if tp.isTrackableRef =>
+  //     tp.symbol.termRef
+  //   case _ => this
 
   /** The capture set consisting of exactly this reference */
   final def singletonCaptureSet(using Context): CaptureSet.Const =
     if mySingletonCaptureSet == null then
-      mySingletonCaptureSet = CaptureSet(this.normalizedRef)
+      mySingletonCaptureSet = CaptureSet(this)
     mySingletonCaptureSet.uncheckedNN
 
   /** The capture set of the type underlying this reference */
@@ -97,27 +98,51 @@ trait CaptureRef extends TypeProxy, ValueType:
    *   x subsumes y  ==>  x* subsumes y, x subsumes y?
    *   x subsumes y  ==>  x* subsumes y*, x? subsumes y?
    *   x: x1.type /\ x1 subsumes y  ==>  x subsumes y
+   *   TODO: Document path cases
    */
   final def subsumes(y: CaptureRef)(using Context): Boolean =
+
+    def subsumingRefs(x: Type, y: Type): Boolean = x match
+      case x: CaptureRef => y match
+        case y: CaptureRef => x.subsumes(y)
+        case _ => false
+      case _ => false
+
+    def viaInfo(info: Type)(test: Type => Boolean): Boolean = info.match
+      case info: SingletonCaptureRef => test(info)
+      case info: AndType => viaInfo(info.tp1)(test) || viaInfo(info.tp2)(test)
+      case info: OrType => viaInfo(info.tp1)(test) && viaInfo(info.tp2)(test)
+      case _ => false
+
     (this eq y)
     || this.isRootCapability
     || y.match
         case y: TermRef =>
-          (y.prefix eq this)
-          || y.info.match
-              case y1: SingletonCaptureRef => this.subsumes(y1)
+            y.prefix.match
+              case ypre: CaptureRef =>
+                this.subsumes(ypre)
+                || this.match
+                    case x @ TermRef(xpre: CaptureRef, _) if x.symbol == y.symbol =>
+                      // To show `{x.f} <:< {y.f}`, it is important to prove `x` and `y`
+                      // are equvalent, which means `x =:= y` in terms of subtyping,
+                      // not just `{x} =:= {y}` in terms of subcapturing.
+                      // It is possible to construct two singleton types `x` and `y`,
+                      // which subsume each other, but are not equal references.
+                      // See `tests/neg-custom-args/captures/path-prefix.scala` for example.
+                      withMode(Mode.IgnoreCaptures) {TypeComparer.isSameRef(xpre, ypre)}
+                    case _ =>
+                      false
               case _ => false
+          || viaInfo(y.info)(subsumingRefs(this, _))
         case MaybeCapability(y1) => this.stripMaybe.subsumes(y1)
         case _ => false
     || this.match
         case ReachCapability(x1) => x1.subsumes(y.stripReach)
-        case x: TermRef =>
-          x.info match
-            case x1: SingletonCaptureRef => x1.subsumes(y)
-            case _ => false
+        case x: TermRef => viaInfo(x.info)(subsumingRefs(_, y))
         case x: TermParamRef => subsumesExistentially(x, y)
         case x: TypeRef => assumedContainsOf(x).contains(y)
         case _ => false
+  end subsumes
 
   def assumedContainsOf(x: TypeRef)(using Context): SimpleIdentitySet[CaptureRef] =
     CaptureSet.assumedContains.getOrElse(x, SimpleIdentitySet.empty)

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

@@ -374,7 +374,7 @@ object CaptureSet:
 
   def apply(elems: CaptureRef*)(using Context): CaptureSet.Const =
     if elems.isEmpty then empty
-    else Const(SimpleIdentitySet(elems.map(_.normalizedRef.ensuring(_.isTrackableRef))*))
+    else Const(SimpleIdentitySet(elems.map(_.ensuring(_.isTrackableRef))*))
 
   def apply(elems: Refs)(using Context): CaptureSet.Const =
     if elems.isEmpty then empty else Const(elems)
@@ -508,7 +508,11 @@ object CaptureSet:
         !noUniversal
       else elem match
         case elem: TermRef if level.isDefined =>
-          elem.symbol.ccLevel <= level
+          elem.prefix match
+            case prefix: CaptureRef =>
+              levelOK(prefix)
+            case _ =>
+              elem.symbol.ccLevel <= level
         case elem: ThisType if level.isDefined =>
           elem.cls.ccLevel.nextInner <= level
         case ReachCapability(elem1) =>