Merge branch 'main' into export-diagnostics

.github/workflows/ci.yaml

@@ -255,6 +255,11 @@ jobs:
         run: |
           ./project/scripts/sbt ";scala3-interfaces/mimaReportBinaryIssues ;scala3-library-bootstrapped/mimaReportBinaryIssues ;scala3-library-bootstrappedJS/mimaReportBinaryIssues; tasty-core-bootstrapped/mimaReportBinaryIssues; stdlib-bootstrapped/mimaReportBinaryIssues"
 
+      - name: TASTy MiMa
+        run: |
+          # This script cleans the compiler and recompiles it from scratch (keep as last run)
+          ./project/scripts/stdlib-bootstrapped-tasty-mima.sh
+
   community_build_a:
     runs-on: [self-hosted, Linux]
     container:

.gitignore

@@ -99,3 +99,6 @@ docs/_spec/.jekyll-metadata
 # scaladoc related
 scaladoc/output/
 
+#coverage
+coverage/
+

.gitmodules

@@ -28,10 +28,6 @@
 [submodule "community-build/community-projects/scala-xml"]
 	path = community-build/community-projects/scala-xml
 	url = https://github.com/dotty-staging/scala-xml
-[submodule "community-build/community-projects/shapeless"]
-	path = community-build/community-projects/shapeless
-	url = https://github.com/dotty-staging/shapeless
-	branch = shapeless-3-staging
 [submodule "community-build/community-projects/xml-interpolator"]
 	path = community-build/community-projects/xml-interpolator
 	url = https://github.com/dotty-staging/xml-interpolator.git
@@ -222,3 +218,6 @@
 [submodule "community-build/community-projects/parboiled2"]
 	path = community-build/community-projects/parboiled2
 	url = https://github.com/dotty-staging/parboiled2.git
+[submodule "community-build/community-projects/shapeless-3"]
+	path = community-build/community-projects/shapeless-3
+	url = https://github.com/dotty-staging/shapeless-3.git

community-build/src/scala/dotty/communitybuild/projects.scala

@@ -140,7 +140,7 @@ final case class SbtCommunityProject(
       case Some(ivyHome) => List(s"-Dsbt.ivy.home=$ivyHome")
       case _ => Nil
     extraSbtArgs ++ sbtProps ++ List(
-      "-sbt-version", "1.9.0",
+      "-sbt-version", "1.9.3",
       "-Dsbt.supershell=false",
       s"-Ddotty.communitybuild.dir=$communitybuildDir",
       s"--addPluginSbtFile=$sbtPluginFilePath"
@@ -366,12 +366,10 @@ object projects:
     // sbtDocCommand = "library/doc" // Does no compile? No idea :/
   )
 
-
-  lazy val shapeless = SbtCommunityProject(
-    project       = "shapeless",
-    sbtTestCommand = """set deriving/scalacOptions -= "-Xfatal-warnings"; set typeable/scalacOptions -= "-Xfatal-warnings"; test""",
-      // selectively disable -Xfatal-warnings due to deprecations
-    sbtDocCommand = forceDoc("typeable", "deriving", "data"),
+  lazy val shapeless3 = SbtCommunityProject(
+    project = "shapeless-3",
+    sbtTestCommand = "testJVM; testJS",
+    sbtDocCommand = forceDoc("typeable", "deriving"),
     scalacOptions = SbtCommunityProject.scalacOptions.filter(_ != "-Ysafe-init"), // due to -Xfatal-warnings
   )
 
@@ -796,7 +794,7 @@ def allProjects = List(
   projects.minitest,
   projects.fastparse,
   projects.stdLib213,
-  projects.shapeless,
+  projects.shapeless3,
   projects.xmlInterpolator,
   projects.effpi,
   projects.sconfig,

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

@@ -91,7 +91,7 @@ class CommunityBuildTestC:
   @Test def scalaz = projects.scalaz.run()
   @Test def scas = projects.scas.run()
   @Test def sconfig = projects.sconfig.run()
-  @Test def shapeless = projects.shapeless.run()
+  @Test def shapeless3 = projects.shapeless3.run()
   @Test def sourcecode = projects.sourcecode.run()
   @Test def specs2 = projects.specs2.run()
 

compiler/src/dotty/tools/MainGenericRunner.scala

@@ -148,7 +148,7 @@ object MainGenericRunner {
     case (o @ javaOption(striped)) :: tail =>
       processArgs(tail, settings.withJavaArgs(striped).withScalaArgs(o))
     case (o @ scalaOption(_*)) :: tail =>
-      val remainingArgs = (CommandLineParser.expandArg(o) ++ tail).toList
+      val remainingArgs = CommandLineParser.expandArg(o) ++ tail
       processArgs(remainingArgs, settings)
     case (o @ colorOption(_*)) :: tail =>
       processArgs(tail, settings.withScalaArgs(o))

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

@@ -763,9 +763,14 @@ trait BCodeSkelBuilder extends BCodeHelpers {
       for (p <- params) { locals.makeLocal(p.symbol) }
       // debug assert((params.map(p => locals(p.symbol).tk)) == asmMethodType(methSymbol).getArgumentTypes.toList, "debug")
 
-      if (params.size > MaximumJvmParameters) {
+      val paramsSize = params.map { param =>
+        val tpeTym = param.symbol.info.typeSymbol
+        if tpeTym == defn.LongClass || tpeTym == defn.DoubleClass then 2 else 1
+      }.sum
+      if (paramsSize > MaximumJvmParameters) {
         // SI-7324
-        report.error(em"Platform restriction: a parameter list's length cannot exceed $MaximumJvmParameters.", ctx.source.atSpan(methSymbol.span))
+        val info = if paramsSize == params.length then "" else " (Long and Double count as 2)" // https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.3.3
+        report.error(em"Platform restriction: a parameter list's length cannot exceed $MaximumJvmParameters$info.", ctx.source.atSpan(methSymbol.span))
         return
       }
 

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

@@ -73,11 +73,20 @@ class CompilationUnit protected (val source: SourceFile) {
   /** List of all comments present in this compilation unit */
   var comments: List[Comment] = Nil
 
+  /** This is used to record dependencies to invalidate during incremental
+   *  compilation, but only if `ctx.runZincPhases` is true.
+   */
+  val depRecorder: sbt.DependencyRecorder = sbt.DependencyRecorder()
+
   /** Suspends the compilation unit by thowing a SuspendException
    *  and recording the suspended compilation unit
    */
   def suspend()(using Context): Nothing =
     assert(isSuspendable)
+    // Clear references to symbols that may become stale. No need to call
+    // `depRecorder.sendToZinc()` since all compilation phases will be rerun
+    // when this unit is unsuspended.
+    depRecorder.clear()
     if !suspended then
       if (ctx.settings.XprintSuspension.value)
         report.echo(i"suspended: $this")

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

@@ -240,15 +240,16 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
 
       for (phase <- ctx.base.allPhases)
         if (phase.isRunnable)
-          Stats.trackTime(s"$phase ms ") {
+          Stats.trackTime(s"phase time ms/$phase") {
             val start = System.currentTimeMillis
             val profileBefore = profiler.beforePhase(phase)
             units = phase.runOn(units)
             profiler.afterPhase(phase, profileBefore)
             if (ctx.settings.Xprint.value.containsPhase(phase))
               for (unit <- units)
-                lastPrintedTree =
-                  printTree(lastPrintedTree)(using ctx.fresh.setPhase(phase.next).setCompilationUnit(unit))
+                def printCtx(unit: CompilationUnit) = phase.printingContext(
+                  ctx.fresh.setPhase(phase.next).setCompilationUnit(unit))
+                lastPrintedTree = printTree(lastPrintedTree)(using printCtx(unit))
             report.informTime(s"$phase ", start)
             Stats.record(s"total trees at end of $phase", ast.Trees.ntrees)
             for (unit <- units)

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

@@ -205,12 +205,12 @@ object desugar {
 
   def makeImplicitParameters(
       tpts: List[Tree], implicitFlag: FlagSet,
-      mkParamName: () => TermName,
+      mkParamName: Int => TermName,
       forPrimaryConstructor: Boolean = false
   )(using Context): List[ValDef] =
     for (tpt, i) <- tpts.zipWithIndex yield {
        val paramFlags: FlagSet = if (forPrimaryConstructor) LocalParamAccessor else Param
-       val epname = mkParamName()
+       val epname = mkParamName(i)
        ValDef(epname, tpt, EmptyTree).withFlags(paramFlags | implicitFlag)
     }
 
@@ -254,7 +254,7 @@ object desugar {
           // using clauses, we only need names that are unique among the
           // parameters of the method since shadowing does not affect
           // implicit resolution in Scala 3.
-          mkParamName = () =>
+          mkParamName = i =>
             val index = seenContextBounds + 1 // Start at 1 like FreshNameCreator.
             val ret = ContextBoundParamName(EmptyTermName, index)
             seenContextBounds += 1
@@ -1602,9 +1602,12 @@ object desugar {
       case vd: ValDef => vd
     }
 
-  def makeContextualFunction(formals: List[Tree], body: Tree, erasedParams: List[Boolean])(using Context): Function = {
+  def makeContextualFunction(formals: List[Tree], paramNamesOrNil: List[TermName], body: Tree, erasedParams: List[Boolean])(using Context): Function = {
     val mods = Given
-    val params = makeImplicitParameters(formals, mods, mkParamName = () => ContextFunctionParamName.fresh())
+    val params = makeImplicitParameters(formals, mods,
+      mkParamName = i =>
+        if paramNamesOrNil.isEmpty then ContextFunctionParamName.fresh()
+        else paramNamesOrNil(i))
     FunctionWithMods(params, body, Modifiers(mods), erasedParams)
   }
 

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

@@ -376,6 +376,17 @@ trait TreeInfo[T <: Untyped] { self: Trees.Instance[T] =>
     case _ =>
       tree.tpe.isInstanceOf[ThisType]
   }
+
+  /** Under capture checking, an extractor for qualified roots `cap[Q]`.
+   */
+  object QualifiedRoot:
+
+    def unapply(tree: Apply)(using Context): Option[String] = tree match
+      case Apply(fn, Literal(lit) :: Nil) if fn.symbol == defn.Caps_capIn =>
+        Some(lit.value.asInstanceOf[String])
+      case _ =>
+        None
+  end QualifiedRoot
 }
 
 trait UntypedTreeInfo extends TreeInfo[Untyped] { self: Trees.Instance[Untyped] =>
@@ -799,12 +810,37 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
     }
   }
 
+  /** An extractor for def of a closure contained the block of the closure,
+   *  possibly with type ascriptions.
+   */
+  object possiblyTypedClosureDef:
+    def unapply(tree: Tree)(using Context): Option[DefDef] = tree match
+      case Typed(expr, _)  => unapply(expr)
+      case _ => closureDef.unapply(tree)
+
   /** If tree is a closure, its body, otherwise tree itself */
   def closureBody(tree: Tree)(using Context): Tree = tree match {
     case closureDef(meth) => meth.rhs
     case _ => tree
   }
 
+  /** Is `mdef` an eta-expansion of a method reference? To recognize this, we use
+   *  the following criterion: A method definition is an eta expansion, if
+   *  it contains at least one term paramter, the parameter has a zero extent span,
+   *  and the right hand side is either an application or a closure with'
+   *  an anonymous method that's itself characterized as an eta expansion.
+   */
+  def isEtaExpansion(mdef: DefDef)(using Context): Boolean =
+    !rhsOfEtaExpansion(mdef).isEmpty
+
+  def rhsOfEtaExpansion(mdef: DefDef)(using Context): Tree = mdef.paramss match
+    case (param :: _) :: _ if param.asInstanceOf[Tree].span.isZeroExtent =>
+      mdef.rhs match
+        case rhs: Apply => rhs
+        case closureDef(mdef1) => rhsOfEtaExpansion(mdef1)
+        case _ => EmptyTree
+    case _ => EmptyTree
+
   /** The variables defined by a pattern, in reverse order of their appearance. */
   def patVars(tree: Tree)(using Context): List[Symbol] = {
     val acc = new TreeAccumulator[List[Symbol]] { outer =>
@@ -954,7 +990,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
   def isStructuralTermSelectOrApply(tree: Tree)(using Context): Boolean = {
     def isStructuralTermSelect(tree: Select) =
       def hasRefinement(qualtpe: Type): Boolean = qualtpe.dealias match
-        case defn.PolyOrErasedFunctionOf(_) =>
+        case defn.PolyFunctionOf(_) =>
           false
         case RefinedType(parent, rname, rinfo) =>
           rname == tree.name || hasRefinement(parent)

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

@@ -1344,10 +1344,17 @@ object Trees {
         case tree: SeqLiteral if (elems eq tree.elems) && (elemtpt eq tree.elemtpt) => tree
         case _ => finalize(tree, untpd.SeqLiteral(elems, elemtpt)(sourceFile(tree)))
       }
-      def Inlined(tree: Tree)(call: tpd.Tree, bindings: List[MemberDef], expansion: Tree)(using Context): Inlined = tree match {
-        case tree: Inlined if (call eq tree.call) && (bindings eq tree.bindings) && (expansion eq tree.expansion) => tree
-        case _ => finalize(tree, untpd.Inlined(call, bindings, expansion)(sourceFile(tree)))
-      }
+      // Positions of trees are automatically pushed down except when we reach an Inlined tree. Therefore, we
+      // make sure the new expansion has a position by copying the one of the original Inlined tree.
+      def Inlined(tree: Inlined)(call: tpd.Tree, bindings: List[MemberDef], expansion: Tree)(using Context): Inlined =
+        if (call eq tree.call) && (bindings eq tree.bindings) && (expansion eq tree.expansion) then tree
+        else
+          // Copy the span from the original Inlined tree if the new expansion doesn't have a span.
+          val expansionWithSpan =
+            if expansion.span.exists then expansion
+            else expansion.withSpan(tree.expansion.span)
+          finalize(tree, untpd.Inlined(call, bindings, expansionWithSpan)(sourceFile(tree)))
+
       def Quote(tree: Tree)(body: Tree, tags: List[Tree])(using Context): Quote = tree match {
         case tree: Quote if (body eq tree.body) && (tags eq tree.tags) => tree
         case _ => finalize(tree, untpd.Quote(body, tags)(sourceFile(tree)))
@@ -1589,6 +1596,9 @@ object Trees {
             case tree @ TypeDef(name, rhs) =>
               cpy.TypeDef(tree)(name, transform(rhs))
             case tree @ Template(constr, parents, self, _) if tree.derived.isEmpty =>
+              // Currently we do not have cases where we expect `tree.derived` to contain trees for typed trees.
+              // If it is the case we will fall in `transformMoreCases` and throw an exception there.
+              // In the future we might keep the `derived` clause after typing, in that case we might want to start handling it here.
               cpy.Template(tree)(transformSub(constr), transform(tree.parents), Nil, transformSub(self), transformStats(tree.body, tree.symbol))
             case Import(expr, selectors) =>
               cpy.Import(tree)(transform(expr), selectors)

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

@@ -349,24 +349,27 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
   /** An anonymous class
    *
-   *      new parents { forwarders }
+   *      new parents { termForwarders; typeAliases }
    *
-   *  where `forwarders` contains forwarders for all functions in `fns`.
-   *  @param parents    a non-empty list of class types
-   *  @param fns        a non-empty of functions for which forwarders should be defined in the class.
-   *  The class has the same owner as the first function in `fns`.
-   *  Its position is the union of all functions in `fns`.
+   *  @param parents        a non-empty list of class types
+   *  @param termForwarders a non-empty list of forwarding definitions specified by their name and the definition they forward to.
+   *  @param typeMembers    a possibly-empty list of type members specified by their name and their right hand side.
+   *
+   *  The class has the same owner as the first function in `termForwarders`.
+   *  Its position is the union of all symbols in `termForwarders`.
    */
-  def AnonClass(parents: List[Type], fns: List[TermSymbol], methNames: List[TermName])(using Context): Block = {
-    AnonClass(fns.head.owner, parents, fns.map(_.span).reduceLeft(_ union _)) { cls =>
-      def forwarder(fn: TermSymbol, name: TermName) = {
+  def AnonClass(parents: List[Type], termForwarders: List[(TermName, TermSymbol)],
+      typeMembers: List[(TypeName, TypeBounds)] = Nil)(using Context): Block = {
+    AnonClass(termForwarders.head._2.owner, parents, termForwarders.map(_._2.span).reduceLeft(_ union _)) { cls =>
+      def forwarder(name: TermName, fn: TermSymbol) = {
         val fwdMeth = fn.copy(cls, name, Synthetic | Method | Final).entered.asTerm
         for overridden <- fwdMeth.allOverriddenSymbols do
           if overridden.is(Extension) then fwdMeth.setFlag(Extension)
           if !overridden.is(Deferred) then fwdMeth.setFlag(Override)
         DefDef(fwdMeth, ref(fn).appliedToArgss(_))
       }
-      fns.lazyZip(methNames).map(forwarder)
+      termForwarders.map((name, sym) => forwarder(name, sym)) ++
+      typeMembers.map((name, info) => TypeDef(newSymbol(cls, name, Synthetic, info).entered))
     }
   }
 
@@ -748,7 +751,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       }
     }
 
-    override def Inlined(tree: Tree)(call: Tree, bindings: List[MemberDef], expansion: Tree)(using Context): Inlined = {
+    override def Inlined(tree: Inlined)(call: Tree, bindings: List[MemberDef], expansion: Tree)(using Context): Inlined = {
       val tree1 = untpdCpy.Inlined(tree)(call, bindings, expansion)
       tree match {
         case tree: Inlined if sameTypes(bindings, tree.bindings) && (expansion.tpe eq tree.expansion.tpe) =>
@@ -1149,7 +1152,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
     def etaExpandCFT(using Context): Tree =
       def expand(target: Tree, tp: Type)(using Context): Tree = tp match
-        case defn.ContextFunctionType(argTypes, resType, _) =>
+        case defn.ContextFunctionType(argTypes, resType) =>
           val anonFun = newAnonFun(
             ctx.owner,
             MethodType.companion(isContextual = true)(argTypes, resType),

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

@@ -149,7 +149,10 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     case Floating
   }
 
-  /** {x1, ..., xN} T   (only relevant under captureChecking) */
+  /** {x1, ..., xN} T   (only relevant under captureChecking)
+   *  Created when parsing function types so that capture set and result type
+   *  is combined in a single node.
+   */
   case class CapturesAndResult(refs: List[Tree], parent: Tree)(implicit @constructorOnly src: SourceFile) extends TypTree
 
   /** A type tree appearing somewhere in the untyped DefDef of a lambda, it will be typed using `tpFun`.
@@ -512,6 +515,9 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def captureRoot(using Context): Select =
     Select(scalaDot(nme.caps), nme.CAPTURE_ROOT)
 
+  def captureRootIn(using Context): Select =
+    Select(scalaDot(nme.caps), nme.capIn)
+
   def makeRetaining(parent: Tree, refs: List[Tree], annotName: TypeName)(using Context): Annotated =
     Annotated(parent, New(scalaAnnotationDot(annotName), List(refs)))