Merge branch 'main' into new-lazy-vals

Author: szymon-rd

community-build/community-projects/play-json

@@ -3144,7 +3144,23 @@ class JSCodeGen()(using genCtx: Context) {
       val tpe = atPhase(elimErasedValueTypePhase) {
         sym.info.finalResultType
       }
-      unbox(boxedResult, tpe)
+      if (tpe.isRef(defn.BoxedUnitClass) && sym.isGetter) {
+        /* Work around to reclaim Scala 2 erasure behavior, assumed by the test
+         * NonNativeJSTypeTest.defaultValuesForFields.
+         * Scala 2 erases getters of `Unit`-typed fields as returning `Unit`
+         * (not `BoxedUnit`). Therefore, when called in expression position,
+         * the call site introduces an explicit `BoxedUnit.UNIT`. Even if the
+         * field has not been initialized at all (with `= _`), this results in
+         * an actual `()` value.
+         * In Scala 3, the same pattern returns `null`, as a `BoxedUnit`, so we
+         * introduce here an explicit `()` value.
+         * TODO We should remove this branch if the upstream test is updated
+         * not to assume such a strict interpretation of erasure.
+         */
+        js.Block(boxedResult, js.Undefined())
+      } else {
+        unbox(boxedResult, tpe)
+      }
     }
   }
 

community-build/community-projects/stdLib213

@@ -121,6 +121,11 @@ extension (tp: Type)
     case _ =>
       tp
 
+  def isCapturingType(using Context): Boolean =
+    tp match
+      case CapturingType(_, _) => true
+      case _ => false
+
 extension (sym: Symbol)
 
   /** Does this symbol allow results carrying the universal capability?

compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala

@@ -42,12 +42,20 @@ object CheckCaptures:
   end Pre
 
   /** A class describing environments.
-   *  @param owner    the current owner
-   *  @param captured the caputure set containing all references to tracked free variables outside of boxes
-   *  @param isBoxed  true if the environment is inside a box (in which case references are not counted)
-   *  @param outer0   the next enclosing environment
+   *  @param owner         the current owner
+   *  @param nestedInOwner true if the environment is a temporary one nested in the owner's environment,
+   *                       and does not have a different actual owner symbol (this happens when doing box adaptation).
+   *  @param captured      the caputure set containing all references to tracked free variables outside of boxes
+   *  @param isBoxed       true if the environment is inside a box (in which case references are not counted)
+   *  @param outer0        the next enclosing environment
    */
-  case class Env(owner: Symbol, captured: CaptureSet, isBoxed: Boolean, outer0: Env | Null):
+  case class Env(
+    owner: Symbol,
+    nestedInOwner: Boolean,
+    captured: CaptureSet,
+    isBoxed: Boolean,
+    outer0: Env | Null
+  ):
     def outer = outer0.nn
 
     def isOutermost = outer0 == null
@@ -204,7 +212,7 @@ class CheckCaptures extends Recheck, SymTransformer:
         report.error(i"$header included in allowed capture set ${res.blocking}", pos)
 
     /** The current environment */
-    private var curEnv: Env = Env(NoSymbol, CaptureSet.empty, isBoxed = false, null)
+    private var curEnv: Env = Env(NoSymbol, nestedInOwner = false, CaptureSet.empty, isBoxed = false, null)
 
     private val myCapturedVars: util.EqHashMap[Symbol, CaptureSet] = EqHashMap()
 
@@ -249,8 +257,12 @@ class CheckCaptures extends Recheck, SymTransformer:
       if !cs.isAlwaysEmpty then
         forallOuterEnvsUpTo(ctx.owner.topLevelClass) { env =>
           val included = cs.filter {
-            case ref: TermRef => env.owner.isProperlyContainedIn(ref.symbol.owner)
-            case ref: ThisType => env.owner.isProperlyContainedIn(ref.cls)
+            case ref: TermRef =>
+              (env.nestedInOwner || env.owner != ref.symbol.owner)
+                && env.owner.isContainedIn(ref.symbol.owner)
+            case ref: ThisType =>
+              (env.nestedInOwner || env.owner != ref.cls)
+                && env.owner.isContainedIn(ref.cls)
             case _ => false
           }
           capt.println(i"Include call capture $included in ${env.owner}")
@@ -439,7 +451,7 @@ class CheckCaptures extends Recheck, SymTransformer:
       if !Synthetics.isExcluded(sym) then
         val saved = curEnv
         val localSet = capturedVars(sym)
-        if !localSet.isAlwaysEmpty then curEnv = Env(sym, localSet, isBoxed = false, curEnv)
+        if !localSet.isAlwaysEmpty then curEnv = Env(sym, nestedInOwner = false, localSet, isBoxed = false, curEnv)
         try super.recheckDefDef(tree, sym)
         finally
           interpolateVarsIn(tree.tpt)
@@ -455,7 +467,7 @@ class CheckCaptures extends Recheck, SymTransformer:
       val localSet = capturedVars(cls)
       for parent <- impl.parents do // (1)
         checkSubset(capturedVars(parent.tpe.classSymbol), localSet, parent.srcPos)
-      if !localSet.isAlwaysEmpty then curEnv = Env(cls, localSet, isBoxed = false, curEnv)
+      if !localSet.isAlwaysEmpty then curEnv = Env(cls, nestedInOwner = false, localSet, isBoxed = false, curEnv)
       try
         val thisSet = cls.classInfo.selfType.captureSet.withDescription(i"of the self type of $cls")
         checkSubset(localSet, thisSet, tree.srcPos) // (2)
@@ -495,14 +507,20 @@ class CheckCaptures extends Recheck, SymTransformer:
       recheckFinish(result, arg, pt)
     */
 
-    /** If expected type `pt` is boxed, don't propagate free variables.
+    /** If expected type `pt` is boxed and the tree is a function or a reference,
+     *  don't propagate free variables.
      *  Otherwise, if the result type is boxed, simulate an unboxing by
      *  adding all references in the boxed capture set to the current environment.
      */
     override def recheck(tree: Tree, pt: Type = WildcardType)(using Context): Type =
       if tree.isTerm && pt.isBoxedCapturing then
         val saved = curEnv
-        curEnv = Env(curEnv.owner, CaptureSet.Var(), isBoxed = true, curEnv)
+
+        tree match
+          case _: RefTree | closureDef(_) =>
+            curEnv = Env(curEnv.owner, nestedInOwner = false, CaptureSet.Var(), isBoxed = true, curEnv)
+          case _ =>
+
         try super.recheck(tree, pt)
         finally curEnv = saved
       else
@@ -593,25 +611,121 @@ class CheckCaptures extends Recheck, SymTransformer:
 
       /** Adapt function type `actual`, which is `aargs -> ares` (possibly with dependencies)
        *  to `expected` type.
+       *  It returns the adapted type along with the additionally captured variable
+       *  during adaptation.
        *   @param reconstruct  how to rebuild the adapted function type
        */
       def adaptFun(actual: Type, aargs: List[Type], ares: Type, expected: Type,
-          covariant: Boolean,
-          reconstruct: (List[Type], Type) => Type): Type =
-        val (eargs, eres) = expected.dealias match
-          case defn.FunctionOf(eargs, eres, _, _) => (eargs, eres)
-          case _ => (aargs.map(_ => WildcardType), WildcardType)
-        val aargs1 = aargs.zipWithConserve(eargs)(adapt(_, _, !covariant))
-        val ares1 = adapt(ares, eres, covariant)
-        if (ares1 eq ares) && (aargs1 eq aargs) then actual
-        else reconstruct(aargs1, ares1)
-
-      def adapt(actual: Type, expected: Type, covariant: Boolean): Type = actual.dealias match
-        case actual @ CapturingType(parent, refs) =>
-          val parent1 = adapt(parent, expected, covariant)
-          if actual.isBoxed != expected.isBoxedCapturing then
+          covariant: Boolean, boxed: Boolean,
+          reconstruct: (List[Type], Type) => Type): (Type, CaptureSet) =
+        val saved = curEnv
+        curEnv = Env(curEnv.owner, nestedInOwner = true, CaptureSet.Var(), isBoxed = false, if boxed then null else curEnv)
+
+        try
+          val (eargs, eres) = expected.dealias.stripCapturing match
+            case defn.FunctionOf(eargs, eres, _, _) => (eargs, eres)
+            case expected: MethodType => (expected.paramInfos, expected.resType)
+            case expected @ RefinedType(_, _, rinfo: MethodType) if defn.isFunctionType(expected) => (rinfo.paramInfos, rinfo.resType)
+            case _ => (aargs.map(_ => WildcardType), WildcardType)
+          val aargs1 = aargs.zipWithConserve(eargs) { (aarg, earg) => adapt(aarg, earg, !covariant) }
+          val ares1 = adapt(ares, eres, covariant)
+
+          val resTp =
+            if (ares1 eq ares) && (aargs1 eq aargs) then actual
+            else reconstruct(aargs1, ares1)
+
+          (resTp, curEnv.captured)
+        finally
+          curEnv = saved
+
+      /** Adapt type function type `actual` to the expected type.
+       *  @see [[adaptFun]]
+       */
+      def adaptTypeFun(
+          actual: Type, ares: Type, expected: Type,
+          covariant: Boolean, boxed: Boolean,
+          reconstruct: Type => Type): (Type, CaptureSet) =
+        val saved = curEnv
+        curEnv = Env(curEnv.owner, nestedInOwner = true, CaptureSet.Var(), isBoxed = false, if boxed then null else curEnv)
+
+        try
+          val eres = expected.dealias.stripCapturing match
+            case RefinedType(_, _, rinfo: PolyType) => rinfo.resType
+            case expected: PolyType => expected.resType
+            case _ => WildcardType
+
+          val ares1 = adapt(ares, eres, covariant)
+
+          val resTp =
+            if ares1 eq ares then actual
+            else reconstruct(ares1)
+
+          (resTp, curEnv.captured)
+        finally
+          curEnv = saved
+      end adaptTypeFun
+
+      def adaptInfo(actual: Type, expected: Type, covariant: Boolean): String =
+        val arrow = if covariant then "~~>" else "<~~"
+        i"adapting $actual $arrow $expected"
+
+      /** Destruct a capturing type `tp` to a tuple (cs, tp0, boxed),
+       *  where `tp0` is not a capturing type.
+       * 
+       *  If `tp` is a nested capturing type, the return tuple always represents
+       *  the innermost capturing type. The outer capture annotations can be
+       *  reconstructed with the returned function.
+       */
+      def destructCapturingType(tp: Type, reconstruct: Type => Type = x => x): ((Type, CaptureSet, Boolean), Type => Type) =
+        tp.dealias match
+          case tp @ CapturingType(parent, cs) =>
+            if parent.dealias.isCapturingType then
+              destructCapturingType(parent, res => reconstruct(tp.derivedCapturingType(res, cs)))
+            else
+              ((parent, cs, tp.isBoxed), reconstruct)
+          case actual =>
+            ((actual, CaptureSet(), false), reconstruct)
+
+      def adapt(actual: Type, expected: Type, covariant: Boolean): Type = trace(adaptInfo(actual, expected, covariant), recheckr, show = true) {
+        if expected.isInstanceOf[WildcardType] then actual
+        else
+          val ((parent, cs, actualIsBoxed), recon) = destructCapturingType(actual)
+
+          val needsAdaptation = actualIsBoxed != expected.isBoxedCapturing
+          val insertBox = needsAdaptation && covariant != actualIsBoxed
+
+          val (parent1, cs1) = parent match {
+            case actual @ AppliedType(tycon, args) if defn.isNonRefinedFunction(actual) =>
+              val (parent1, leaked) = adaptFun(parent, args.init, args.last, expected, covariant, insertBox,
+                  (aargs1, ares1) => actual.derivedAppliedType(tycon, aargs1 :+ ares1))
+              (parent1, leaked ++ cs)
+            case actual @ RefinedType(_, _, rinfo: MethodType) if defn.isFunctionType(actual) =>
+              // TODO Find a way to combine handling of generic and dependent function types (here and elsewhere)
+              val (parent1, leaked) = adaptFun(parent, rinfo.paramInfos, rinfo.resType, expected, covariant, insertBox,
+                (aargs1, ares1) =>
+                  rinfo.derivedLambdaType(paramInfos = aargs1, resType = ares1)
+                    .toFunctionType(isJava = false, alwaysDependent = true))
+              (parent1, leaked ++ cs)
+            case actual: MethodType =>
+              val (parent1, leaked) = adaptFun(parent, actual.paramInfos, actual.resType, expected, covariant, insertBox,
+                (aargs1, ares1) =>
+                  actual.derivedLambdaType(paramInfos = aargs1, resType = ares1))
+              (parent1, leaked ++ cs)
+            case actual @ RefinedType(p, nme, rinfo: PolyType) if defn.isFunctionOrPolyType(actual) =>
+              val (parent1, leaked) = adaptTypeFun(parent, rinfo.resType, expected, covariant, insertBox,
+                ares1 =>
+                  val rinfo1 = rinfo.derivedLambdaType(rinfo.paramNames, rinfo.paramInfos, ares1)
+                  val actual1 = actual.derivedRefinedType(p, nme, rinfo1)
+                  actual1
+              )
+              (parent1, leaked ++ cs)
+            case _ =>
+              (parent, cs)
+          }
+
+          if needsAdaptation then
             val criticalSet =          // the set which is not allowed to have `*`
-              if covariant then refs   // can't box with `*`
+              if covariant then cs1    // can't box with `*`
               else expected.captureSet // can't unbox with `*`
             if criticalSet.isUniversal then
               // We can't box/unbox the universal capability. Leave `actual` as it is
@@ -627,20 +741,13 @@ class CheckCaptures extends Recheck, SymTransformer:
                       |since one of their capture sets contains the root capability `*`""",
                 pos)
               }
-              if covariant == actual.isBoxed then markFree(refs, pos)
-              CapturingType(parent1, refs, boxed = !actual.isBoxed)
+              if !insertBox then  // unboxing
+                markFree(criticalSet, pos)
+              recon(CapturingType(parent1, cs1, !actualIsBoxed))
           else
-            actual.derivedCapturingType(parent1, refs)
-        case actual @ AppliedType(tycon, args) if defn.isNonRefinedFunction(actual) =>
-          adaptFun(actual, args.init, args.last, expected, covariant,
-              (aargs1, ares1) => actual.derivedAppliedType(tycon, aargs1 :+ ares1))
-        case actual @ RefinedType(_, _, rinfo: MethodType) if defn.isFunctionType(actual) =>
-          // TODO Find a way to combine handling of generic and dependent function types (here and elsewhere)
-          adaptFun(actual, rinfo.paramInfos, rinfo.resType, expected, covariant,
-            (aargs1, ares1) =>
-              rinfo.derivedLambdaType(paramInfos = aargs1, resType = ares1)
-                .toFunctionType(isJava = false, alwaysDependent = true))
-        case _ => actual
+            recon(CapturingType(parent1, cs1, actualIsBoxed))
+      }
+
 
       var actualw = actual.widenDealias
       actual match

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

@@ -150,6 +150,7 @@ private sealed trait VerboseSettings:
   val VprofileSortedBy = ChoiceSetting("-Vprofile-sorted-by", "key", "Show metrics about sources and internal representations sorted by given column name", List("name", "path", "lines", "tokens", "tasty", "complexity"), "")
   val VprofileDetails = IntSetting("-Vprofile-details", "Show metrics about sources and internal representations of the most complex methods", 0)
   val VreplMaxPrintElements: Setting[Int] = IntSetting("-Vrepl-max-print-elements", "Number of elements to be printed before output is truncated.", 1000)
+  val VreplMaxPrintCharacters: Setting[Int] = IntSetting("-Vrepl-max-print-characters", "Number of characters to be printed before output is truncated.", 50000)
 
 /** -W "Warnings" settings
  */

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

@@ -9,6 +9,7 @@ import scala.util.control.NonFatal
 import Contexts._, Names._, Phases._, Symbols._
 import printing.{ Printer, Showable }, printing.Formatting._, printing.Texts._
 import transform.MegaPhase
+import reporting.{Message, NoExplanation}
 
 /** This object provides useful implicit decorators for types defined elsewhere */
 object Decorators {
@@ -57,6 +58,9 @@ object Decorators {
       padding + s.replace("\n", "\n" + padding)
   end extension
 
+  extension (str: => String)
+    def toMessage: Message = reporting.NoExplanation(str)
+
   /** Implements a findSymbol method on iterators of Symbols that
    *  works like find but avoids Option, replacing None with NoSymbol.
    */

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -997,6 +997,7 @@ class Definitions {
   @tu lazy val ErasedParamAnnot: ClassSymbol = requiredClass("scala.annotation.internal.ErasedParam")
   @tu lazy val InvariantBetweenAnnot: ClassSymbol = requiredClass("scala.annotation.internal.InvariantBetween")
   @tu lazy val MainAnnot: ClassSymbol = requiredClass("scala.main")
+  @tu lazy val MappedAlternativeAnnot: ClassSymbol = requiredClass("scala.annotation.internal.MappedAlternative")
   @tu lazy val MigrationAnnot: ClassSymbol = requiredClass("scala.annotation.migration")
   @tu lazy val NowarnAnnot: ClassSymbol = requiredClass("scala.annotation.nowarn")
   @tu lazy val TransparentTraitAnnot: ClassSymbol = requiredClass("scala.annotation.transparentTrait")

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

@@ -571,6 +571,7 @@ object Flags {
   val GivenOrImplicit: FlagSet               = Given | Implicit
   val GivenOrImplicitVal: FlagSet            = GivenOrImplicit.toTermFlags
   val GivenMethod: FlagSet                   = Given | Method
+  val LazyGiven: FlagSet                     = Given | Lazy
   val InlineOrProxy: FlagSet                 = Inline | InlineProxy                           // An inline method or inline argument proxy */
   val InlineMethod: FlagSet                  = Inline | Method
   val InlineParam: FlagSet                   = Inline | Param

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

@@ -204,6 +204,12 @@ class TypeApplications(val self: Type) extends AnyVal {
     }
   }
 
+  /** Substitute in `self` the type parameters of `tycon` by some other types. */
+  final def substTypeParams(tycon: Type, to: List[Type])(using Context): Type =
+    (tycon.typeParams: @unchecked) match
+      case LambdaParam(lam, _) :: _ => self.substParams(lam, to)
+      case params: List[Symbol @unchecked] => self.subst(params, to)
+
   /** If `self` is a higher-kinded type, its type parameters, otherwise Nil */
   final def hkTypeParams(using Context): List[TypeParamInfo] =
     if (isLambdaSub) typeParams else Nil