Merge remote-tracking branch 'origin/main'

Author: gorilskij

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

@@ -40,6 +40,18 @@ trait BCodeSkelBuilder extends BCodeHelpers {
 
   lazy val NativeAttr: Symbol = requiredClass[scala.native]
 
+  /** The destination of a value generated by `genLoadTo`. */
+  enum LoadDestination:
+    /** The value is put on the stack, and control flows through to the next opcode. */
+    case FallThrough
+    /** The value is put on the stack, and control flow is transferred to the given `label`. */
+    case Jump(label: asm.Label)
+    /** The value is RETURN'ed from the enclosing method. */
+    case Return
+    /** The value is ATHROW'n. */
+    case Throw
+  end LoadDestination
+
   /*
    * There's a dedicated PlainClassBuilder for each CompilationUnit,
    * which simplifies the initialization of per-class data structures in `genPlainClass()` which in turn delegates to `initJClass()`
@@ -379,21 +391,21 @@ trait BCodeSkelBuilder extends BCodeHelpers {
     /* ---------------- Part 1 of program points, ie Labels in the ASM world ---------------- */
 
     /*
-     *  A jump is represented as an Apply node whose symbol denotes a LabelDef, the target of the jump.
-     *  The `jumpDest` map is used to:
-     *    (a) find the asm.Label for the target, given an Apply node's symbol;
-     *    (b) anchor an asm.Label in the instruction stream, given a LabelDef node.
-     *  In other words, (a) is necessary when visiting a jump-source, and (b) when visiting a jump-target.
-     *  A related map is `labelDef`: it has the same keys as `jumpDest` but its values are LabelDef nodes not asm.Labels.
-     *
+     *  A jump is represented as a Return node whose `from` symbol denotes a Labeled's Bind node, the target of the jump.
+     *  The `jumpDest` map is used to find the `LoadDestination` at the end of the `Labeled` block, as well as the
+     *  corresponding expected type. The `LoadDestination` can never be `FallThrough` here.
      */
-    var jumpDest: immutable.Map[ /* Labeled or LabelDef */ Symbol, asm.Label ] = null
-    def programPoint(labelSym: Symbol): asm.Label = {
+    var jumpDest: immutable.Map[ /* Labeled */ Symbol, (BType, LoadDestination) ] = null
+    def registerJumpDest(labelSym: Symbol, expectedType: BType, dest: LoadDestination): Unit = {
+      assert(labelSym.is(Label), s"trying to register a jump-dest for a non-label symbol, at: ${labelSym.span}")
+      assert(dest != LoadDestination.FallThrough, s"trying to register a FallThrough dest for label, at: ${labelSym.span}")
+      assert(!jumpDest.contains(labelSym), s"trying to register a second jump-dest for label, at: ${labelSym.span}")
+      jumpDest += (labelSym -> (expectedType, dest))
+    }
+    def findJumpDest(labelSym: Symbol): (BType, LoadDestination) = {
       assert(labelSym.is(Label), s"trying to map a non-label symbol to an asm.Label, at: ${labelSym.span}")
       jumpDest.getOrElse(labelSym, {
-        val pp = new asm.Label
-        jumpDest += (labelSym -> pp)
-        pp
+        abort(s"unknown label symbol, for label at: ${labelSym.span}")
       })
     }
 
@@ -566,7 +578,7 @@ trait BCodeSkelBuilder extends BCodeHelpers {
     def resetMethodBookkeeping(dd: DefDef) = {
       val rhs = dd.rhs
       locals.reset(isStaticMethod = methSymbol.isStaticMember)
-      jumpDest = immutable.Map.empty[ /* LabelDef */ Symbol, asm.Label ]
+      jumpDest = immutable.Map.empty
 
       // check previous invocation of genDefDef exited as many varsInScope as it entered.
       assert(varsInScope == null, "Unbalanced entering/exiting of GenBCode's genBlock().")
@@ -799,20 +811,16 @@ trait BCodeSkelBuilder extends BCodeHelpers {
 
         def emitNormalMethodBody(): Unit = {
           val veryFirstProgramPoint = currProgramPoint()
-          genLoad(trimmedRhs, returnType)
-
-          trimmedRhs match {
-            case (_: Return) | Block(_, (_: Return)) => ()
-            case (_: Apply) | Block(_, (_: Apply)) if trimmedRhs.symbol eq defn.throwMethod => ()
-            case tpd.EmptyTree =>
-              report.error("Concrete method has no definition: " + dd + (
-                if (ctx.settings.Ydebug.value) "(found: " + methSymbol.owner.info.decls.toList.mkString(", ") + ")"
-                else ""),
-                ctx.source.atSpan(NoSpan)
-              )
-            case _ =>
-              bc emitRETURN returnType
-          }
+
+          if trimmedRhs == tpd.EmptyTree then
+            report.error("Concrete method has no definition: " + dd + (
+              if (ctx.settings.Ydebug.value) "(found: " + methSymbol.owner.info.decls.toList.mkString(", ") + ")"
+              else ""),
+              ctx.source.atSpan(NoSpan)
+            )
+          else
+            genLoadTo(trimmedRhs, returnType, LoadDestination.Return)
+
           if (emitVars) {
             // add entries to LocalVariableTable JVM attribute
             val onePastLastProgramPoint = currProgramPoint()
@@ -905,7 +913,7 @@ trait BCodeSkelBuilder extends BCodeHelpers {
       }
     }
 
-    def genLoad(tree: Tree, expectedType: BType): Unit
+    def genLoadTo(tree: Tree, expectedType: BType, dest: LoadDestination): Unit
 
   } // end of class PlainSkelBuilder
 

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

@@ -397,7 +397,7 @@ trait BCodeSyncAndTry extends BCodeBodyBuilder {
 
     /* `tmp` (if non-null) is the symbol of the local-var used to preserve the result of the try-body, see `guardResult` */
     def emitFinalizer(finalizer: Tree, tmp: Symbol, isDuplicate: Boolean): Unit = {
-      var saved: immutable.Map[ /* LabelDef */ Symbol, asm.Label ] = null
+      var saved: immutable.Map[ /* Labeled */ Symbol, (BType, LoadDestination) ] = null
       if (isDuplicate) {
         saved = jumpDest
       }

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

@@ -61,7 +61,7 @@ class GenBCode extends Phase {
 
   private var myPrimitives: DottyPrimitives = null
 
-  def run(using Context): Unit =
+  override def run(using Context): Unit =
     if myPrimitives == null then myPrimitives = new DottyPrimitives(ctx)
     new GenBCodePipeline(
       DottyBackendInterface(outputDir, superCallsMap),

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

@@ -11,7 +11,7 @@ import Denotations.Denotation
 import typer.Typer
 import typer.ImportInfo.withRootImports
 import Decorators._
-import io.{AbstractFile, VirtualFile}
+import io.AbstractFile
 import Phases.unfusedPhases
 
 import util._

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

@@ -393,6 +393,16 @@ object desugar {
     vparam.withMods(mods & (GivenOrImplicit | Erased | hasDefault) | Param)
   }
 
+  def mkApply(fn: Tree, paramss: List[ParamClause])(using Context): Tree =
+    paramss.foldLeft(fn) { (fn, params) => params match
+      case TypeDefs(params) =>
+        TypeApply(fn, params.map(refOfDef))
+      case (vparam: ValDef) :: _ if vparam.mods.is(Given) =>
+        Apply(fn, params.map(refOfDef)).setApplyKind(ApplyKind.Using)
+      case _ =>
+        Apply(fn, params.map(refOfDef))
+    }
+
   /** The expansion of a class definition. See inline comments for what is involved */
   def classDef(cdef: TypeDef)(using Context): Tree = {
     val impl @ Template(constr0, _, self, _) = cdef.rhs
@@ -588,7 +598,7 @@ object desugar {
       }
 
     // new C[Ts](paramss)
-    lazy val creatorExpr = {
+    lazy val creatorExpr =
       val vparamss = constrVparamss match
         case (vparam :: _) :: _ if vparam.mods.is(Implicit) => // add a leading () to match class parameters
           Nil :: constrVparamss
@@ -607,7 +617,6 @@ object desugar {
         }
       }
       ensureApplied(nu)
-    }
 
     val copiedAccessFlags = if migrateTo3 then EmptyFlags else AccessFlags
 
@@ -892,48 +901,50 @@ object desugar {
     }
   }
 
+  def extMethod(mdef: DefDef, extParamss: List[ParamClause])(using Context): DefDef =
+    cpy.DefDef(mdef)(
+      name = normalizeName(mdef, mdef.tpt).asTermName,
+      paramss =
+        if mdef.name.isRightAssocOperatorName then
+          val (typaramss, paramss) = mdef.paramss.span(isTypeParamClause) // first extract type parameters
+
+          paramss match
+            case params :: paramss1 => // `params` must have a single parameter and without `given` flag
+
+              def badRightAssoc(problem: String) =
+                report.error(i"right-associative extension method $problem", mdef.srcPos)
+                extParamss ++ mdef.paramss
+
+              params match
+                case ValDefs(vparam :: Nil) =>
+                  if !vparam.mods.is(Given) then
+                    // we merge the extension parameters with the method parameters,
+                    // swapping the operator arguments:
+                    // e.g.
+                    //   extension [A](using B)(c: C)(using D)
+                    //     def %:[E](f: F)(g: G)(using H): Res = ???
+                    // will be encoded as
+                    //   def %:[A](using B)[E](f: F)(c: C)(using D)(g: G)(using H): Res = ???
+                    val (leadingUsing, otherExtParamss) = extParamss.span(isUsingOrTypeParamClause)
+                    leadingUsing ::: typaramss ::: params :: otherExtParamss ::: paramss1
+                  else
+                    badRightAssoc("cannot start with using clause")
+                case _ =>
+                  badRightAssoc("must start with a single parameter")
+            case _ =>
+              // no value parameters, so not an infix operator.
+              extParamss ++ mdef.paramss
+        else
+          extParamss ++ mdef.paramss
+    ).withMods(mdef.mods | ExtensionMethod)
+
   /** Transform extension construct to list of extension methods */
   def extMethods(ext: ExtMethods)(using Context): Tree = flatTree {
-    for mdef <- ext.methods yield
-      defDef(
-        cpy.DefDef(mdef)(
-          name = normalizeName(mdef, ext).asTermName,
-          paramss =
-            if mdef.name.isRightAssocOperatorName then
-              val (typaramss, paramss) = mdef.paramss.span(isTypeParamClause) // first extract type parameters
-
-              paramss match
-                case params :: paramss1 => // `params` must have a single parameter and without `given` flag
-
-                  def badRightAssoc(problem: String) =
-                    report.error(i"right-associative extension method $problem", mdef.srcPos)
-                    ext.paramss ++ mdef.paramss
-
-                  params match
-                    case ValDefs(vparam :: Nil) =>
-                      if !vparam.mods.is(Given) then
-                        // we merge the extension parameters with the method parameters,
-                        // swapping the operator arguments:
-                        // e.g.
-                        //   extension [A](using B)(c: C)(using D)
-                        //     def %:[E](f: F)(g: G)(using H): Res = ???
-                        // will be encoded as
-                        //   def %:[A](using B)[E](f: F)(c: C)(using D)(g: G)(using H): Res = ???
-                        val (leadingUsing, otherExtParamss) = ext.paramss.span(isUsingOrTypeParamClause)
-                        leadingUsing ::: typaramss ::: params :: otherExtParamss ::: paramss1
-                      else
-                        badRightAssoc("cannot start with using clause")
-                    case _ =>
-                      badRightAssoc("must start with a single parameter")
-                case _ =>
-                  // no value parameters, so not an infix operator.
-                  ext.paramss ++ mdef.paramss
-            else
-              ext.paramss ++ mdef.paramss
-        ).withMods(mdef.mods | ExtensionMethod)
-      )
+    ext.methods map {
+      case exp: Export => exp
+      case mdef: DefDef => defDef(extMethod(mdef, ext.paramss))
+    }
   }
-
   /** Transforms
    *
    *    <mods> type t >: Low <: Hi

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

@@ -117,7 +117,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   case class GenAlias(pat: Tree, expr: Tree)(implicit @constructorOnly src: SourceFile) extends Tree
   case class ContextBounds(bounds: TypeBoundsTree, cxBounds: List[Tree])(implicit @constructorOnly src: SourceFile) extends TypTree
   case class PatDef(mods: Modifiers, pats: List[Tree], tpt: Tree, rhs: Tree)(implicit @constructorOnly src: SourceFile) extends DefTree
-  case class ExtMethods(paramss: List[ParamClause], methods: List[DefDef])(implicit @constructorOnly src: SourceFile) extends Tree
+  case class ExtMethods(paramss: List[ParamClause], methods: List[Tree])(implicit @constructorOnly src: SourceFile) extends Tree
   case class MacroTree(expr: Tree)(implicit @constructorOnly src: SourceFile) extends Tree
 
   case class ImportSelector(imported: Ident, renamed: Tree = EmptyTree, bound: Tree = EmptyTree)(implicit @constructorOnly src: SourceFile) extends Tree {
@@ -640,7 +640,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
       case tree: PatDef if (mods eq tree.mods) && (pats eq tree.pats) && (tpt eq tree.tpt) && (rhs eq tree.rhs) => tree
       case _ => finalize(tree, untpd.PatDef(mods, pats, tpt, rhs)(tree.source))
     }
-    def ExtMethods(tree: Tree)(paramss: List[ParamClause], methods: List[DefDef])(using Context): Tree = tree match
+    def ExtMethods(tree: Tree)(paramss: List[ParamClause], methods: List[Tree])(using Context): Tree = tree match
       case tree: ExtMethods if (paramss eq tree.paramss) && (methods == tree.methods) => tree
       case _ => finalize(tree, untpd.ExtMethods(paramss, methods)(tree.source))
     def ImportSelector(tree: Tree)(imported: Ident, renamed: Tree, bound: Tree)(using Context): Tree = tree match {

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

@@ -81,16 +81,28 @@ trait ConstraintHandling {
     assert(homogenizeArgs == false)
     assert(comparedTypeLambdas == Set.empty)
 
-  def nestingLevel(param: TypeParamRef) = constraint.typeVarOfParam(param) match
+  def nestingLevel(param: TypeParamRef)(using Context) = constraint.typeVarOfParam(param) match
     case tv: TypeVar => tv.nestingLevel
-    case _ => Int.MaxValue
+    case _ =>
+      // This should only happen when reducing match types (in
+      // TrackingTypeComparer#matchCases) or in uncommitable TyperStates (as
+      // asserted in ProtoTypes.constrained) and is special-cased in `levelOK`
+      // below.
+      Int.MaxValue
+
+  /** Is `level` <= `maxLevel` or legal in the current context? */
+  def levelOK(level: Int, maxLevel: Int)(using Context): Boolean =
+    level <= maxLevel ||
+    ctx.isAfterTyper || !ctx.typerState.isCommittable || // Leaks in these cases shouldn't break soundness
+    level == Int.MaxValue // See `nestingLevel` above.
 
   /** If `param` is nested deeper than `maxLevel`, try to instantiate it to a
    *  fresh type variable of level `maxLevel` and return the new variable.
    *  If this isn't possible, throw a TypeError.
    */
   def atLevel(maxLevel: Int, param: TypeParamRef)(using Context): TypeParamRef =
-    if nestingLevel(param) <= maxLevel then return param
+    if levelOK(nestingLevel(param), maxLevel) then
+      return param
     LevelAvoidMap(0, maxLevel)(param) match
       case freshVar: TypeVar => freshVar.origin
       case _ => throw new TypeError(
@@ -129,18 +141,12 @@ trait ConstraintHandling {
 
   /** An approximating map that prevents types nested deeper than maxLevel as
    *  well as WildcardTypes from leaking into the constraint.
-   *  Note that level-checking is turned off after typer and in uncommitable
-   *  TyperState since these leaks should be safe.
    */
   class LevelAvoidMap(topLevelVariance: Int, maxLevel: Int)(using Context) extends TypeOps.AvoidMap:
     variance = topLevelVariance
 
-    /** Are we allowed to refer to types of the given `level`? */
-    private def levelOK(level: Int): Boolean =
-      level <= maxLevel || ctx.isAfterTyper || !ctx.typerState.isCommittable
-
     def toAvoid(tp: NamedType): Boolean =
-      tp.prefix == NoPrefix && !tp.symbol.isStatic && !levelOK(tp.symbol.nestingLevel)
+      tp.prefix == NoPrefix && !tp.symbol.isStatic && !levelOK(tp.symbol.nestingLevel, maxLevel)
 
     /** Return a (possibly fresh) type variable of a level no greater than `maxLevel` which is:
      *  - lower-bounded by `tp` if variance >= 0
@@ -185,7 +191,7 @@ trait ConstraintHandling {
     end legalVar
 
     override def apply(tp: Type): Type = tp match
-      case tp: TypeVar if !tp.isInstantiated && !levelOK(tp.nestingLevel) =>
+      case tp: TypeVar if !tp.isInstantiated && !levelOK(tp.nestingLevel, maxLevel) =>
         legalVar(tp)
       // TypeParamRef can occur in tl bounds
       case tp: TypeParamRef =>
@@ -431,7 +437,6 @@ trait ConstraintHandling {
   final def approximation(param: TypeParamRef, fromBelow: Boolean)(using Context): Type =
     constraint.entry(param) match
       case entry: TypeBounds =>
-        val maxLevel = nestingLevel(param)
         val useLowerBound = fromBelow || param.occursIn(entry.hi)
         val inst = if useLowerBound then fullLowerBound(param) else fullUpperBound(param)
         typr.println(s"approx ${param.show}, from below = $fromBelow, inst = ${inst.show}")
@@ -627,11 +632,7 @@ trait ConstraintHandling {
           case x =>
             // Happens if param was already solved while processing earlier params of the same TypeLambda.
             // See #4720.
-
-            // Should propagate bounds even when param has been solved.
-            // See #11682.
-            lower.forall(addOneBound(_, x, isUpper = true)) &&
-              upper.forall(addOneBound(_, x, isUpper = false))
+            true
         }
       }
     }
@@ -677,6 +678,11 @@ trait ConstraintHandling {
             case t @ TypeParamRef(tl: TypeLambda, n) if comparedTypeLambdas contains tl =>
               val bounds = tl.paramInfos(n)
               range(bounds.lo, bounds.hi)
+            case tl: TypeLambda =>
+              val saved = comparedTypeLambdas
+              comparedTypeLambdas -= tl
+              try mapOver(tl)
+              finally comparedTypeLambdas = saved
             case _ =>
               mapOver(t)
           }