Warn trivial recursion with module prefix (#23278)

Fixes #23277 

First, loosen the test for whether to warn for `module.recur()`. The
`this` assignment has a RHS that is not pure (because of module init)
but `isStable` (and not significant with respect to the warning).

Second, avoid emitting such a `this` assignment if the prefix is the
enclosing module. The existing code checks for a prefix that is
`Enclosing.this`.

Other "aliasing" prefixes are not considered, such as a method with
result `this.type`, since they could execute arbitrary intended effects.

Author: som-snytt

compiler/src/dotty/tools/dotc/transform/TailRec.scala

@@ -196,7 +196,8 @@ class TailRec extends MiniPhase {
         def isInfiniteRecCall(tree: Tree): Boolean = {
           def tailArgOrPureExpr(stat: Tree): Boolean = stat match {
             case stat: ValDef if stat.name.is(TailTempName) || !stat.symbol.is(Mutable) => tailArgOrPureExpr(stat.rhs)
-            case Assign(lhs: Ident, rhs) if lhs.symbol.name.is(TailLocalName) => tailArgOrPureExpr(rhs)
+            case Assign(lhs: Ident, rhs) if lhs.symbol.name.is(TailLocalName) =>
+              tailArgOrPureExpr(rhs) || varForRewrittenThis.exists(_ == lhs.symbol && rhs.tpe.isStable)
             case Assign(lhs: Ident, rhs: Ident) => lhs.symbol == rhs.symbol
             case stat: Ident if stat.symbol.name.is(TailLocalName) => true
             case _ => tpd.isPureExpr(stat)
@@ -345,6 +346,9 @@ class TailRec extends MiniPhase {
               case prefix: This if prefix.symbol == enclosingClass =>
                 // Avoid assigning `this = this`
                 assignParamPairs
+              case prefix if prefix.symbol.is(Module) && prefix.symbol.moduleClass == enclosingClass =>
+                // Avoid assigning `this = MyObject`
+                assignParamPairs
               case _ =>
                 (getVarForRewrittenThis(), noTailTransform(prefix)) :: assignParamPairs
 

tests/warn/i23277.scala

@@ -0,0 +1,22 @@
+
+enum Test:
+  case One
+  case Two(i: Int)
+
+object Test:
+  object Two:
+    def apply(i: Int): Test.Two = Test.Two(i) // warn
+    def apply(i: Int, j: Int): Test.Two = new Test.Two(i+j)
+    def apply(i: Int, s: String): Two = Two(i, s) // warn because unprefixed Two is deemed pure
+    def apply(): Test.Two = other.apply() // nowarn prefix is method call
+    def other: this.type = this
+
+object R extends Runnable:
+  def r: this.type = this
+  override def run() = r.run()
+
+final class C(c: C):
+  def f(i: Int): Int = c.f(i)
+
+@main def main = println:
+  Test.Two(1)