Merge branch 'scala:main' into patch-1

Author: zhongl

.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
 

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

@@ -11,6 +11,7 @@ import Symbols.*, StdNames.*, Annotations.*, Trees.*, Symbols.*
 import Decorators.*, DenotTransformers.*
 import collection.{immutable, mutable}
 import util.{Property, SourceFile}
+import config.Printers.typr
 import NameKinds.{TempResultName, OuterSelectName}
 import typer.ConstFold
 
@@ -1165,6 +1166,21 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       tree
     }
 
+    /** Make sure tree has given symbol. This is called when typing or unpickling
+     *  a ValDef or DefDef. It turns out that under very rare circumstances the symbol
+     *  computed for a tree is not correct. The only known test case is i21755.scala.
+     *  Here we have a self type that mentions a supertype as well as a type parameter
+     *  upper-bounded by the current class and it turns out that we compute the symbol
+     *  for a member method (named `root` in this case) in a subclass to be the
+     *  corresponding symbol in the superclass. It is not known what are the precise
+     *  conditions where this happens, but my guess would be that it's connected to the
+     *  recursion in the self type.
+     */
+    def ensureHasSym(sym: Symbol)(using Context): Unit =
+      if sym.exists && sym != tree.symbol then
+        typr.println(i"correcting definition symbol from ${tree.symbol.showLocated} to ${sym.showLocated}")
+        tree.overwriteType(NamedType(sym.owner.thisType, sym.asTerm.name, sym.denot))
+
     def etaExpandCFT(using Context): Tree =
       def expand(target: Tree, tp: Type)(using Context): Tree = tp match
         case defn.ContextFunctionType(argTypes, resType) =>

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

@@ -132,7 +132,7 @@ object ContextOps:
     }
 
     def packageContext(tree: untpd.PackageDef, pkg: Symbol): Context = inContext(ctx) {
-      if (pkg.is(Package)) ctx.fresh.setOwner(pkg.moduleClass).setTree(tree)
+      if (pkg.is(Package)) ctx.fresh.setOwner(pkg.moduleClass).setTree(tree).setNewScope
       else ctx
     }
 end ContextOps

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

@@ -51,19 +51,23 @@ object SymbolLoaders {
    */
   def enterClass(
       owner: Symbol, name: PreName, completer: SymbolLoader,
-      flags: FlagSet = EmptyFlags, scope: Scope = EmptyScope)(using Context): Symbol = {
-    val cls = newClassSymbol(owner, name.toTypeName.unmangleClassName.decode, flags, completer, compUnitInfo = completer.compilationUnitInfo)
+      flags: FlagSet = EmptyFlags, scope: Scope = EmptyScope, privateWithin: Symbol = NoSymbol,
+  )(using Context): Symbol = {
+    val cls = newClassSymbol(owner, name.toTypeName.unmangleClassName.decode, flags, completer, privateWithin, compUnitInfo = completer.compilationUnitInfo)
     enterNew(owner, cls, completer, scope)
   }
 
   /** Enter module with given `name` into scope of `owner`.
    */
   def enterModule(
       owner: Symbol, name: PreName, completer: SymbolLoader,
-      modFlags: FlagSet = EmptyFlags, clsFlags: FlagSet = EmptyFlags, scope: Scope = EmptyScope)(using Context): Symbol = {
+      modFlags: FlagSet = EmptyFlags, clsFlags: FlagSet = EmptyFlags,
+      scope: Scope = EmptyScope, privateWithin: Symbol = NoSymbol,
+  )(using Context): Symbol = {
     val module = newModuleSymbol(
       owner, name.toTermName.decode, modFlags, clsFlags,
       (module, _) => completer.proxy.withDecls(newScope).withSourceModule(module),
+      privateWithin,
       compUnitInfo = completer.compilationUnitInfo)
     enterNew(owner, module, completer, scope)
     enterNew(owner, module.moduleClass, completer, scope)
@@ -103,13 +107,16 @@ object SymbolLoaders {
    */
   def enterClassAndModule(
       owner: Symbol, name: PreName, completer: SymbolLoader,
-      flags: FlagSet = EmptyFlags, scope: Scope = EmptyScope)(using Context): Unit = {
-    val clazz = enterClass(owner, name, completer, flags, scope)
+      flags: FlagSet = EmptyFlags, scope: Scope = EmptyScope, privateWithin: Symbol = NoSymbol,
+  )(using Context): Unit = {
+    val clazz = enterClass(owner, name, completer, flags, scope, privateWithin)
     val module = enterModule(
       owner, name, completer,
       modFlags = flags.toTermFlags & RetainedModuleValFlags,
       clsFlags = flags.toTypeFlags & RetainedModuleClassFlags,
-      scope = scope)
+      scope = scope,
+      privateWithin = privateWithin,
+    )
   }
 
   /** Enter all toplevel classes and objects in file `src` into package `owner`, provided
@@ -337,7 +344,7 @@ abstract class SymbolLoader extends LazyType { self =>
     val sym = root.symbol
     def associatedFile = root.symbol.associatedFile match
       case file: AbstractFile => file
-      case _ => NoAbstractFile
+      case null => NoAbstractFile
     ctx.profiler.onCompletion(sym, associatedFile)(body)
   }
 

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

@@ -3196,9 +3196,10 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
       cls.is(Sealed) && !cls.hasAnonymousChild
 
     def decompose(cls: Symbol): List[Symbol] =
-      cls.children.map { child =>
-        if child.isTerm then child.info.classSymbol
-        else child
+      cls.children.flatMap { child =>
+        if child.isTerm then
+          child.info.classSymbols // allow enum vals to be decomposed to their enum class (then filtered out) and any mixins
+        else child :: Nil
       }.filter(child => child.exists && child != cls)
 
     def eitherDerivesFromOther(cls1: Symbol, cls2: Symbol): Boolean =
@@ -3231,6 +3232,12 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
   end provablyDisjointClasses
 
   private def provablyDisjointTypeArgs(cls: ClassSymbol, args1: List[Type], args2: List[Type], pending: util.HashSet[(Type, Type)])(using Context): Boolean =
+    // sjrd: I will not be surprised when this causes further issues in the future.
+    // This is a compromise to be able to fix #21295 without breaking the world.
+    def cannotBeNothing(tp: Type): Boolean = tp match
+      case tp: TypeParamRef => cannotBeNothing(tp.paramInfo)
+      case _                => !(tp.loBound.stripTypeVar <:< defn.NothingType)
+
     // It is possible to conclude that two types applied are disjoint by
     // looking at covariant type parameters if the said type parameters
     // are disjoint and correspond to fields.
@@ -3239,9 +3246,20 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
     def covariantDisjoint(tp1: Type, tp2: Type, tparam: TypeParamInfo): Boolean =
       provablyDisjoint(tp1, tp2, pending) && typeparamCorrespondsToField(cls.appliedRef, tparam)
 
-    // In the invariant case, direct type parameter disjointness is enough.
+    // In the invariant case, we have more ways to prove disjointness:
+    // - either the type param corresponds to a field, like in the covariant case, or
+    // - one of the two actual args can never be `Nothing`.
+    // The latter condition, as tested by `cannotBeNothing`, is ad hoc and was
+    // not carefully evaluated to be sound. We have it because we had to
+    // reintroduce the former condition to fix #21295, and alone, that broke a
+    // lot of existing test cases.
+    // Having either one of the two conditions be true is better than not requiring
+    // any, which was the status quo before #21295.
     def invariantDisjoint(tp1: Type, tp2: Type, tparam: TypeParamInfo): Boolean =
-      provablyDisjoint(tp1, tp2, pending)
+      provablyDisjoint(tp1, tp2, pending) && {
+        typeparamCorrespondsToField(cls.appliedRef, tparam)
+          || (cannotBeNothing(tp1) || cannotBeNothing(tp2))
+      }
 
     args1.lazyZip(args2).lazyZip(cls.typeParams).exists {
       (arg1, arg2, tparam) =>