Merge branch 'main' into 22071

Author: HarrisL2

NOTICE.md

@@ -1,6 +1,6 @@
-Dotty (https://dotty.epfl.ch)
-Copyright 2012-2024 EPFL
-Copyright 2012-2024 Lightbend, Inc.
+Scala 3 (https://www.scala-lang.org)
+Copyright 2012-2025 EPFL
+Copyright 2012-2025 Lightbend, Inc. dba Akka
 
 Licensed under the Apache License, Version 2.0 (the "License"):
 http://www.apache.org/licenses/LICENSE-2.0
@@ -11,12 +11,13 @@ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
 
-The dotty compiler frontend has been developed since November 2012 by Martin
-Odersky. It is expected and hoped for that the list of contributors to the
-codebase will grow quickly. Dotty draws inspiration and code from the original
-Scala compiler "nsc", which is developed at scala/scala [1].
+The Scala 3 compiler is also known as Dotty. The Dotty compiler
+frontend has been developed since November 2012 by Martin Odersky. It
+is expected and hoped for that the list of contributors to the
+codebase will grow quickly. Dotty draws inspiration and code from the
+original Scala 2 compiler "nsc", which is still developed at scala/scala [1].
 
-The majority of the dotty codebase is new code, with the exception of the
+The majority of the Dotty codebase is new code, with the exception of the
 components mentioned below. We have for each component tried to come up with a
 list of the original authors in the scala/scala [1] codebase. Apologies if some
 major authors were omitted by oversight.
@@ -28,7 +29,7 @@ major authors were omitted by oversight.
 
   * dotty.tools.dotc.classpath: The classpath handling is taken mostly as is
     from scala/scala [1]. The original authors were Grzegorz Kossakowski,
-    Michał Pociecha, Lukas  Rytz, Jason Zaugg and others.
+    Michał Pociecha, Lukas Rytz, Jason Zaugg and others.
 
   * dotty.tools.dotc.config: The configuration components were adapted and
     extended from scala/scala [1]. The original sources were authored by Paul

community-build/test/scala/dotty/communitybuild/CommunityBuildTest.scala

@@ -68,7 +68,7 @@ class CommunityBuildTestC:
   @Test def fastparse = projects.fastparse.run()
   @Test def geny = projects.geny.run()
   @Test def intent = projects.intent.run()
-  @Test def jacksonModuleScala = projects.jacksonModuleScala.run()
+  //@Test def jacksonModuleScala = projects.jacksonModuleScala.run()
   @Test def libretto = projects.libretto.run()
   @Test def minitest = projects.minitest.run()
   //@Test def onnxScala = projects.onnxScala.run()

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

@@ -515,7 +515,7 @@ trait BCodeSkelBuilder extends BCodeHelpers {
      */
     object locals {
 
-      private val slots = mutable.AnyRefMap.empty[Symbol, Local] // (local-or-param-sym -> Local(BType, name, idx, isSynth))
+      private val slots = mutable.HashMap.empty[Symbol, Local] // (local-or-param-sym -> Local(BType, name, idx, isSynth))
 
       private var nxtIdx = -1 // next available index for local-var
 

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

@@ -185,6 +185,7 @@ object BackendUtils {
     20 -> asm.Opcodes.V20,
     21 -> asm.Opcodes.V21,
     22 -> asm.Opcodes.V22,
-    23 -> asm.Opcodes.V23
+    23 -> asm.Opcodes.V23,
+    24 -> asm.Opcodes.V24
   )
 }

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

@@ -155,6 +155,14 @@ object CompilationUnit {
     unit1
   }
 
+  /** Create a compilation unit corresponding to an in-memory String. 
+   *  Used for `compiletime.testing.typeChecks`.
+   */
+  def apply(name: String, source: String)(using Context): CompilationUnit = {
+    val src = SourceFile.virtual(name = name, content = source, maybeIncomplete = false)
+    new CompilationUnit(src, null)
+  }
+
   /** Create a compilation unit corresponding to `source`.
    *  If `mustExist` is true, this will fail if `source` does not exist.
    */

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

@@ -1086,12 +1086,13 @@ object desugar {
       if mods.isAllOf(Given | Inline | Transparent) then
         report.error("inline given instances cannot be trasparent", cdef)
       var classMods = if mods.is(Given) then mods &~ (Inline | Transparent) | Synthetic else mods
-      if vparamAccessors.exists(_.mods.is(Tracked)) then
+      val newBody = tparamAccessors ::: vparamAccessors ::: normalizedBody ::: caseClassMeths
+      if newBody.collect { case d: ValOrDefDef => d }.exists(_.mods.is(Tracked)) then
         classMods |= Dependent
       cpy.TypeDef(cdef: TypeDef)(
         name = className,
         rhs = cpy.Template(impl)(constr, parents1, clsDerived, self1,
-          tparamAccessors ::: vparamAccessors ::: normalizedBody ::: caseClassMeths)
+          newBody)
       ).withMods(classMods)
     }
 
@@ -1561,6 +1562,12 @@ object desugar {
       rhsOK(rhs)
   }
 
+  val legalTracked: Context ?=> MemberDefTest = {
+    case valdef @ ValDef(_, _, _) =>
+      val sym = valdef.symbol
+      !ctx.owner.exists || ctx.owner.isClass || ctx.owner.is(Case) || ctx.owner.isConstructor || valdef.mods.is(Param) || valdef.mods.is(ParamAccessor)
+  }
+
   def checkOpaqueAlias(tree: MemberDef)(using Context): MemberDef =
     def check(rhs: Tree): MemberDef = rhs match
       case bounds: TypeBoundsTree if bounds.alias.isEmpty =>
@@ -1586,6 +1593,7 @@ object desugar {
         } else tested
       tested = checkOpaqueAlias(tested)
       tested = checkApplicable(Opaque, legalOpaque)
+      tested = checkApplicable(Tracked, legalTracked)
       tested
     case _ =>
       tree
@@ -1659,7 +1667,7 @@ object desugar {
       AppliedTypeTree(
         TypeTree(defn.throwsAlias.typeRef).withSpan(op.span), tpt :: excepts :: Nil)
 
-  private def checkWellFormedTupleElems(elems: List[Tree])(using Context): List[Tree] =
+  def checkWellFormedTupleElems(elems: List[Tree])(using Context): List[Tree] =
     val seen = mutable.Set[Name]()
     for case arg @ NamedArg(name, _) <- elems do
       if seen.contains(name) then
@@ -1736,7 +1744,7 @@ object desugar {
   def adaptPatternArgs(elems: List[Tree], pt: Type)(using Context): List[Tree] =
 
     def reorderedNamedArgs(wildcardSpan: Span): List[untpd.Tree] =
-      var selNames = pt.namedTupleElementTypes.map(_(0))
+      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

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

@@ -223,6 +223,22 @@ object CheckCaptures:
       checkNotUniversal.traverse(tpe.widen)
   end checkNotUniversalInUnboxedResult
 
+  trait CheckerAPI:
+    /** Complete symbol info of a val or a def */
+    def completeDef(tree: ValOrDefDef, sym: Symbol)(using Context): Type
+
+    extension [T <: Tree](tree: T)
+
+      /** Set new type of the tree if none was installed yet. */
+      def setNuType(tpe: Type): Unit
+
+      /** The new type of the tree, or if none was installed, the original type */
+      def nuType(using Context): Type
+
+      /** Was a new type installed for this tree? */
+      def hasNuType: Boolean
+  end CheckerAPI
+
 class CheckCaptures extends Recheck, SymTransformer:
   thisPhase =>
 
@@ -243,7 +259,7 @@ class CheckCaptures extends Recheck, SymTransformer:
 
   val ccState1 = new CCState // Dotty problem: Rename to ccState ==> Crash in ExplicitOuter
 
-  class CaptureChecker(ictx: Context) extends Rechecker(ictx):
+  class CaptureChecker(ictx: Context) extends Rechecker(ictx), CheckerAPI:
 
     /** The current environment */
     private val rootEnv: Env = inContext(ictx):
@@ -261,10 +277,6 @@ class CheckCaptures extends Recheck, SymTransformer:
      */
     private val todoAtPostCheck = new mutable.ListBuffer[() => Unit]
 
-    override def keepType(tree: Tree) =
-      super.keepType(tree)
-      || tree.isInstanceOf[Try]  // type of `try` needs tp be checked for * escapes
-
     /** Instantiate capture set variables appearing contra-variantly to their
      *  upper approximation.
      */
@@ -286,8 +298,8 @@ class CheckCaptures extends Recheck, SymTransformer:
      */
     private def interpolateVarsIn(tpt: Tree)(using Context): Unit =
       if tpt.isInstanceOf[InferredTypeTree] then
-        interpolator().traverse(tpt.knownType)
-          .showing(i"solved vars in ${tpt.knownType}", capt)
+        interpolator().traverse(tpt.nuType)
+          .showing(i"solved vars in ${tpt.nuType}", capt)
       for msg <- ccState.approxWarnings do
         report.warning(msg, tpt.srcPos)
       ccState.approxWarnings.clear()
@@ -501,11 +513,11 @@ class CheckCaptures extends Recheck, SymTransformer:
             then ("\nThis is often caused by a local capability$where\nleaking as part of its result.", fn.srcPos)
             else if arg.span.exists then ("", arg.srcPos)
             else ("", fn.srcPos)
-          disallowRootCapabilitiesIn(arg.knownType, NoSymbol,
+          disallowRootCapabilitiesIn(arg.nuType, NoSymbol,
             i"Type variable $pname of $sym", "be instantiated to", addendum, pos)
 
           val param = fn.symbol.paramNamed(pname)
-          if param.isUseParam then markFree(arg.knownType.deepCaptureSet, pos)
+          if param.isUseParam then markFree(arg.nuType.deepCaptureSet, pos)
     end disallowCapInTypeArgs
 
     override def recheckIdent(tree: Ident, pt: Type)(using Context): Type =
@@ -769,8 +781,8 @@ class CheckCaptures extends Recheck, SymTransformer:
      */
     def checkContains(tree: TypeApply)(using Context): Unit = tree match
       case ContainsImpl(csArg, refArg) =>
-        val cs = csArg.knownType.captureSet
-        val ref = refArg.knownType
+        val cs = csArg.nuType.captureSet
+        val ref = refArg.nuType
         capt.println(i"check contains $cs , $ref")
         ref match
           case ref: CaptureRef if ref.isTracked =>
@@ -852,7 +864,7 @@ class CheckCaptures extends Recheck, SymTransformer:
               case _ =>
                 (sym, "")
             disallowRootCapabilitiesIn(
-              tree.tpt.knownType, carrier, i"Mutable $sym", "have type", addendum, sym.srcPos)
+              tree.tpt.nuType, carrier, i"Mutable $sym", "have type", addendum, sym.srcPos)
           checkInferredResult(super.recheckValDef(tree, sym), tree)
       finally
         if !sym.is(Param) then
@@ -1533,7 +1545,7 @@ class CheckCaptures extends Recheck, SymTransformer:
     private val setup: SetupAPI = thisPhase.prev.asInstanceOf[Setup]
 
     override def checkUnit(unit: CompilationUnit)(using Context): Unit =
-      setup.setupUnit(unit.tpdTree, completeDef)
+      setup.setupUnit(unit.tpdTree, this)
       collectCapturedMutVars.traverse(unit.tpdTree)
 
       if ctx.settings.YccPrintSetup.value then
@@ -1676,7 +1688,7 @@ class CheckCaptures extends Recheck, SymTransformer:
               traverseChildren(tp)
 
       if tree.isInstanceOf[InferredTypeTree] then
-        checker.traverse(tree.knownType)
+        checker.traverse(tree.nuType)
     end healTypeParam
 
     /** Under the unsealed policy: Arrays are like vars, check that their element types
@@ -1716,10 +1728,10 @@ class CheckCaptures extends Recheck, SymTransformer:
             check(tree)
         def check(tree: Tree)(using Context) = tree match
           case TypeApply(fun, args) =>
-            fun.knownType.widen match
+            fun.nuType.widen match
               case tl: PolyType =>
                 val normArgs = args.lazyZip(tl.paramInfos).map: (arg, bounds) =>
-                  arg.withType(arg.knownType.forceBoxStatus(
+                  arg.withType(arg.nuType.forceBoxStatus(
                     bounds.hi.isBoxedCapturing | bounds.lo.isBoxedCapturing))
                 checkBounds(normArgs, tl)
                 args.lazyZip(tl.paramNames).foreach(healTypeParam(_, _, fun.symbol))
@@ -1739,7 +1751,7 @@ class CheckCaptures extends Recheck, SymTransformer:
           def traverse(t: Tree)(using Context) = t match
             case tree: InferredTypeTree =>
             case tree: New =>
-            case tree: TypeTree => checkAppliedTypesIn(tree.withKnownType)
+            case tree: TypeTree => checkAppliedTypesIn(tree.withType(tree.nuType))
             case _ => traverseChildren(t)
         checkApplied.traverse(unit)
     end postCheck

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

@@ -19,19 +19,16 @@ import printing.{Printer, Texts}, Texts.{Text, Str}
 import collection.mutable
 import CCState.*
 import dotty.tools.dotc.util.NoSourcePosition
+import CheckCaptures.CheckerAPI
 
 /** Operations accessed from CheckCaptures */
 trait SetupAPI:
 
-  /** The operation to recheck a ValDef or DefDef */
-  type DefRecheck = (tpd.ValOrDefDef, Symbol) => Context ?=> Type
-
   /** Setup procedure to run for each compilation unit
    *   @param tree       the typed tree of the unit to check
-   *   @param recheckDef the recheck method to run on completion of symbols with
-   *                     inferred (result-) types
+   *   @param checker    the capture checker which will run subsequently.
    */
-  def setupUnit(tree: Tree, recheckDef: DefRecheck)(using Context): Unit
+  def setupUnit(tree: Tree, checker: CheckerAPI)(using Context): Unit
 
   /** Symbol is a term member of a class that was not capture checked
    *  The info of these symbols is made fluid.
@@ -378,15 +375,6 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
     tp2
   end transformExplicitType
 
-  /** Transform type of tree, and remember the transformed type as the type the tree */
-  private def transformTT(tree: TypeTree, boxed: Boolean)(using Context): Unit =
-    if !tree.hasRememberedType then
-      val transformed =
-        if tree.isInferred
-        then transformInferredType(tree.tpe)
-        else transformExplicitType(tree.tpe, tptToCheck = tree)
-      tree.rememberType(if boxed then box(transformed) else transformed)
-
   /** Substitute parameter symbols in `from` to paramRefs in corresponding
    *  method or poly types `to`. We use a single BiTypeMap to do everything.
    *  @param from  a list of lists of type or term parameter symbols of a curried method
@@ -436,7 +424,17 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
     atPhase(thisPhase.next)(sym.info)
 
   /** A traverser that adds knownTypes and updates symbol infos */
-  def setupTraverser(recheckDef: DefRecheck) = new TreeTraverserWithPreciseImportContexts:
+  def setupTraverser(checker: CheckerAPI) = new TreeTraverserWithPreciseImportContexts:
+    import checker.*
+
+    /** Transform type of tree, and remember the transformed type as the type the tree */
+    private def transformTT(tree: TypeTree, boxed: Boolean)(using Context): Unit =
+      if !tree.hasNuType then
+        val transformed =
+          if tree.isInferred
+          then transformInferredType(tree.tpe)
+          else transformExplicitType(tree.tpe, tptToCheck = tree)
+        tree.setNuType(if boxed then box(transformed) else transformed)
 
     /** Transform the type of a val or var or the result type of a def */
     def transformResultType(tpt: TypeTree, sym: Symbol)(using Context): Unit =
@@ -464,7 +462,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
             traverse(parent)
           case _ =>
             traverseChildren(tp)
-      addDescription.traverse(tpt.knownType)
+      addDescription.traverse(tpt.nuType)
     end transformResultType
 
     def traverse(tree: Tree)(using Context): Unit =
@@ -504,7 +502,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
 
         case tree @ SeqLiteral(elems, tpt: TypeTree) =>
           traverse(elems)
-          tpt.rememberType(box(transformInferredType(tpt.tpe)))
+          tpt.setNuType(box(transformInferredType(tpt.tpe)))
 
         case tree: Block =>
           inNestedLevel(traverseChildren(tree))
@@ -537,22 +535,22 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
         // with special treatment for constructors.
         def localReturnType =
           if sym.isConstructor then constrReturnType(sym.info, sym.paramSymss)
-          else tree.tpt.knownType
+          else tree.tpt.nuType
 
         // A test whether parameter signature might change. This returns true if one of
-        // the parameters has a remembered type. The idea here is that we store a remembered
+        // the parameters has a new type installee. The idea here is that we store a new
         // type only if the transformed type is different from the original.
         def paramSignatureChanges = tree.match
           case tree: DefDef =>
             tree.paramss.nestedExists:
-              case param: ValDef => param.tpt.hasRememberedType
-              case param: TypeDef => param.rhs.hasRememberedType
+              case param: ValDef => param.tpt.hasNuType
+              case param: TypeDef => param.rhs.hasNuType
           case _ => false
 
         // A symbol's signature changes if some of its parameter types or its result type
         // have a new type installed here (meaning hasRememberedType is true)
         def signatureChanges =
-          tree.tpt.hasRememberedType && !sym.isConstructor || paramSignatureChanges
+          tree.tpt.hasNuType && !sym.isConstructor || paramSignatureChanges
 
         // Replace an existing symbol info with inferred types where capture sets of
         // TypeParamRefs and TermParamRefs are put in correspondence by BiTypeMaps with the
@@ -616,7 +614,7 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
                   capt.println(i"forcing $sym, printing = ${ctx.mode.is(Mode.Printing)}")
                   //if ctx.mode.is(Mode.Printing) then new Error().printStackTrace()
                   denot.info = newInfo
-                  recheckDef(tree, sym)
+                  completeDef(tree, sym)
             updateInfo(sym, updatedInfo)
 
       case tree: Bind =>
@@ -833,8 +831,8 @@ class Setup extends PreRecheck, SymTransformer, SetupAPI:
   /** Run setup on a compilation unit with given `tree`.
    *  @param recheckDef   the function to run for completing a val or def
    */
-  def setupUnit(tree: Tree, recheckDef: DefRecheck)(using Context): Unit =
-    setupTraverser(recheckDef).traverse(tree)(using ctx.withPhase(thisPhase))
+  def setupUnit(tree: Tree, checker: CheckerAPI)(using Context): Unit =
+    setupTraverser(checker).traverse(tree)(using ctx.withPhase(thisPhase))
 
   // ------ Checks to run after main capture checking --------------------------
 

compiler/src/dotty/tools/dotc/classpath/DirectoryClassPath.scala

@@ -229,7 +229,7 @@ final class CtSymClassPath(ctSym: java.nio.file.Path, release: Int) extends Clas
 
   // e.g. "java.lang" -> Seq(/876/java/lang, /87/java/lang, /8/java/lang))
   private val packageIndex: scala.collection.Map[String, scala.collection.Seq[Path]] = {
-    val index = collection.mutable.AnyRefMap[String, collection.mutable.ListBuffer[Path]]()
+    val index = collection.mutable.HashMap[String, collection.mutable.ListBuffer[Path]]()
     val isJava12OrHigher = scala.util.Properties.isJavaAtLeast("12")
     rootsForRelease.foreach(root => Files.walk(root).iterator().asScala.filter(Files.isDirectory(_)).foreach { p =>
       val moduleNamePathElementCount = if (isJava12OrHigher) 1 else 0