Add special-case logic for function calls returning this.type

I copied all the relevant code over from `scala/scala:2.13.x`, so the
behaviour should be equivalent to Scala 2.13.

Author: cb372

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

@@ -308,6 +308,160 @@ trait TreeInfo[T <: Untyped] { self: Trees.Instance[T] =>
     case Block(_, expr) => forallResults(expr, p)
     case _ => p(tree)
   }
+
+  /** Applications in Scala can have one of the following shapes:
+   *
+   *    1) naked core: Ident(_) or Select(_, _) or basically anything else
+   *    2) naked core with targs: TypeApply(core, targs) or AppliedTypeTree(core, targs)
+   *    3) apply or several applies wrapping a core: Apply(core, _), or Apply(Apply(core, _), _), etc
+   *
+   *  This class provides different ways to decompose applications and simplifies their analysis.
+   *
+   *  ***Examples***
+   *  (TypeApply in the examples can be replaced with AppliedTypeTree)
+   *
+   *    Ident(foo):
+   *      * callee = Ident(foo)
+   *      * core = Ident(foo)
+   *      * targs = Nil
+   *      * argss = Nil
+   *
+   *    TypeApply(foo, List(targ1, targ2...))
+   *      * callee = TypeApply(foo, List(targ1, targ2...))
+   *      * core = foo
+   *      * targs = List(targ1, targ2...)
+   *      * argss = Nil
+   *
+   *    Apply(foo, List(arg1, arg2...))
+   *      * callee = foo
+   *      * core = foo
+   *      * targs = Nil
+   *      * argss = List(List(arg1, arg2...))
+   *
+   *    Apply(Apply(foo, List(arg21, arg22, ...)), List(arg11, arg12...))
+   *      * callee = foo
+   *      * core = foo
+   *      * targs = Nil
+   *      * argss = List(List(arg11, arg12...), List(arg21, arg22, ...))
+   *
+   *    Apply(Apply(TypeApply(foo, List(targs1, targs2, ...)), List(arg21, arg22, ...)), List(arg11, arg12...))
+   *      * callee = TypeApply(foo, List(targs1, targs2, ...))
+   *      * core = foo
+   *      * targs = Nil
+   *      * argss = List(List(arg11, arg12...), List(arg21, arg22, ...))
+   */
+  final class Applied(val tree: Tree) {
+    /** The tree stripped of the possibly nested applications.
+     *  The original tree if it's not an application.
+     */
+    def callee: Tree = {
+      @tailrec
+      def loop(tree: Tree): Tree = tree match {
+        case Apply(fn, _) => loop(fn)
+        case tree         => tree
+      }
+      loop(tree)
+    }
+
+    /** The `callee` unwrapped from type applications.
+     *  The original `callee` if it's not a type application.
+     */
+    def core: Tree = callee match {
+      case TypeApply(fn, _)       => fn
+      case AppliedTypeTree(fn, _) => fn
+      case tree                   => tree
+    }
+
+    /** The type arguments of the `callee`.
+     *  `Nil` if the `callee` is not a type application.
+     */
+    def targs: List[Tree] = callee match {
+      case TypeApply(_, args)       => args
+      case AppliedTypeTree(_, args) => args
+      case _                        => Nil
+    }
+
+    /** (Possibly multiple lists of) value arguments of an application.
+     *  `Nil` if the `callee` is not an application.
+     */
+    def argss: List[List[Tree]] = {
+      def loop(tree: Tree): List[List[Tree]] = tree match {
+        case Apply(fn, args) => loop(fn) :+ args
+        case _               => Nil
+      }
+      loop(tree)
+    }
+  }
+
+  /** Returns a wrapper that knows how to destructure and analyze applications.
+   */
+  final def dissectApplied(tree: Tree) = new Applied(tree)
+
+  /** Equivalent ot disectApplied(tree).core, but more efficient */
+  @scala.annotation.tailrec
+  final def dissectCore(tree: Tree): Tree = tree match {
+    case TypeApply(fun, _) =>
+      dissectCore(fun)
+    case Apply(fun, _) =>
+      dissectCore(fun)
+    case t =>
+      t
+  }
+
+  /** Destructures applications into important subparts described in `Applied` class,
+   *  namely into: core, targs and argss (in the specified order).
+   *
+   *  Trees which are not applications are also accepted. Their callee and core will
+   *  be equal to the input, while targs and argss will be Nil.
+   *
+   *  The provided extractors don't expose all the API of the `Applied` class.
+   *  For advanced use, call `dissectApplied` explicitly and use its methods instead of pattern matching.
+   */
+  object Applied {
+    def apply(tree: Tree): Applied = new Applied(tree)
+
+    def unapply(applied: Applied): Some[(Tree, List[Tree], List[List[Tree]])] =
+      Some((applied.core, applied.targs, applied.argss))
+
+    def unapply(tree: Tree): Some[(Tree, List[Tree], List[List[Tree]])] =
+      unapply(dissectApplied(tree))
+  }
+
+  /** Is tree an application with result `this.type`?
+   *  Accept `b.addOne(x)` and also `xs(i) += x`
+   *  where the op is an assignment operator.
+   */
+  def isThisTypeResult(tree: Tree)(using Context): Boolean = tree match {
+    case Applied(fun @ Select(receiver, op), _, argss) =>
+      tree.tpe match {
+        case ThisType(tref) =>
+          tref.symbol == receiver.symbol
+        case tref: TermRef =>
+          tref.symbol == receiver.symbol || argss.exists(_.exists(tref.symbol == _.symbol))
+        case _ =>
+          def checkSingle(sym: Symbol): Boolean =
+            (sym == receiver.symbol) || {
+              receiver match {
+                case Apply(_, _) => op.isOpAssignmentName                     // xs(i) += x
+                case _ => receiver.symbol != null &&
+                  (receiver.symbol.isGetter || receiver.symbol.isField)       // xs.addOne(x) for var xs
+              }
+            }
+          @tailrec def loop(mt: Type): Boolean = mt match {
+            case m: MethodType =>
+              m.resType match {
+                case ThisType(tref) => checkSingle(tref.symbol)
+                case tref: TermRef  => checkSingle(tref.symbol)
+                case restpe => loop(restpe)
+              }
+            case PolyType(_, restpe) => loop(restpe)
+            case _ => false
+          }
+          fun.symbol != null && loop(fun.symbol.info)
+      }
+    case _ =>
+      tree.tpe.isInstanceOf[ThisType]
+  }
 }
 
 trait UntypedTreeInfo extends TreeInfo[Untyped] { self: Trees.Instance[Untyped] =>

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -3928,7 +3928,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         // so will take the code path that decides on inlining
         val tree1 = adapt(tree, WildcardType, locked)
         checkStatementPurity(tree1)(tree, ctx.owner)
-        if (!ctx.isAfterTyper && !tree.isInstanceOf[Inlined] && ctx.settings.WvalueDiscard.value) {
+        if (!ctx.isAfterTyper && !tree.isInstanceOf[Inlined] && ctx.settings.WvalueDiscard.value && !isThisTypeResult(tree)) {
           report.warning(ValueDiscarding(tree.tpe), tree.srcPos)
         }
         return tpd.Block(tree1 :: Nil, Literal(Constant(())))

tests/neg/warn-value-discard.check

@@ -1,8 +1,16 @@
--- [E172] Potential Issue Error: tests/neg/warn-value-discard.scala:14:35 ----------------------------------------------
-14 |  firstThing().map(_ => secondThing()) // error
+-- [E172] Potential Issue Error: tests/neg/warn-value-discard.scala:15:35 ----------------------------------------------
+15 |  firstThing().map(_ => secondThing()) // error
    |                        ^^^^^^^^^^^^^
    |                        discarded non-Unit value of type Either[Failed, Unit]
--- [E172] Potential Issue Error: tests/neg/warn-value-discard.scala:17:35 ----------------------------------------------
-17 |  firstThing().map(_ => secondThing()) // error
+-- [E172] Potential Issue Error: tests/neg/warn-value-discard.scala:18:35 ----------------------------------------------
+18 |  firstThing().map(_ => secondThing()) // error
    |                        ^^^^^^^^^^^^^
    |                        discarded non-Unit value of type Either[Failed, Unit]
+-- [E172] Potential Issue Error: tests/neg/warn-value-discard.scala:27:36 ----------------------------------------------
+27 |    mutable.Set.empty[String].remove("") // error
+   |    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |    discarded non-Unit value of type Boolean
+-- [E172] Potential Issue Error: tests/neg/warn-value-discard.scala:39:41 ----------------------------------------------
+39 |    mutable.Set.empty[String].subtractOne("") // error
+   |    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |    discarded non-Unit value of type scala.collection.mutable.Set[String]

tests/neg/warn-value-discard.scala

@@ -1,6 +1,7 @@
 // scalac: -Wvalue-discard -Werror
 
 import scala.util.{Either, Right, Left}
+import scala.collection.mutable
 
 case class Failed(msg: String)
 
@@ -16,3 +17,37 @@ def singleExpr(): Either[Failed, Unit] =
 def block(): Either[Failed, Unit] = {
   firstThing().map(_ => secondThing()) // error
 }
+
+class ValueDiscardTest:
+  val field = mutable.Set.empty[String]
+
+  def remove(): Unit =
+    // Set#remove returns a Boolean, not this.type
+    // --> Warning
+    mutable.Set.empty[String].remove("") // error
+
+  // TODO IMHO we don't need to support this,
+  // as it's just as easy to add a @nowarn annotation as a Unit ascription
+  //def removeAscribed(): Unit = {
+  //  mutable.Set.empty[String].remove(""): Unit    // nowarn
+  //}
+
+  def subtract(): Unit =
+    // - Set#subtractOne returns this.type
+    // - receiver is not a field or a local variable (not quite sure what you'd call it)
+    // --> Warning
+    mutable.Set.empty[String].subtractOne("") // error
+
+  def mutateLocalVariable(): Unit = {
+    // - Set#subtractOne returns this.type
+    // - receiver is a local variable
+    // --> No warning
+    val s: mutable.Set[String] = mutable.Set.empty[String]
+    s.subtractOne("")
+  }
+
+  def mutateField(): Unit =
+    // - Set#subtractOne returns this.type
+    // - receiver is a local variable
+    // --> No warning
+    field.subtractOne("")