Add support for trivial body

- Params of method with trivial body are not reported as unused
- Update the test suit

Author: PaulCoral

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

@@ -24,6 +24,7 @@ import dotty.tools.dotc.core.Names.Name
 import dotty.tools.dotc.transform.MegaPhase.MiniPhase
 import dotty.tools.dotc.core.Annotations
 import dotty.tools.dotc.core.Definitions
+import dotty.tools.dotc.core.Types.ConstantType
 
 
 
@@ -96,7 +97,11 @@ class CheckUnused extends MiniPhase:
     _key.unusedDataApply(_.registerDef(tree))
 
   override def prepareForDefDef(tree: tpd.DefDef)(using Context): Context =
-    _key.unusedDataApply(_.registerDef(tree))
+    _key.unusedDataApply{ ud =>
+      import ud.registerTrivial
+      tree.registerTrivial
+      ud.registerDef(tree)
+    }
 
   override def prepareForBind(tree: tpd.Bind)(using Context): Context =
     _key.unusedDataApply(_.registerPatVar(tree))
@@ -266,6 +271,9 @@ object CheckUnused:
     /** All used symbols */
     private val usedDef = MutSet[Symbol]()
 
+    /** Trivial definitions, avoid registering params */
+    private val trivialDefs = MutSet[Symbol]()
+
     /**
      * Push a new Scope of the given type, executes the given Unit and
      * pop it back to the original type.
@@ -310,7 +318,7 @@ object CheckUnused:
       // register the annotations for usage
       registerUsedAnnotation(valOrDef.symbol)
       if !valOrDef.symbol.isUnusedAnnot then
-        if valOrDef.symbol.is(Param) && !isSyntheticMainParam(valOrDef.symbol) then
+        if valOrDef.symbol.is(Param) && !isSyntheticMainParam(valOrDef.symbol) && !valOrDef.symbol.ownerIsTrivial then
           if valOrDef.symbol.isOneOf(GivenOrImplicit) then
             implicitParamInScope += valOrDef
           else
@@ -486,6 +494,22 @@ object CheckUnused:
       /** Annotated with @unused */
       def isUnusedAnnot(using Context): Boolean =
         sym.annotations.exists(a => a.symbol == ctx.definitions.UnusedAnnot)
+
+      def ownerIsTrivial(using Context): Boolean =
+        sym.exists && trivialDefs(sym.owner)
+
+    extension (defdef: tpd.DefDef)
+      // so trivial that it never consumes params
+      private def isTrivial(using Context): Boolean =
+        val rhs = defdef.rhs
+        rhs.symbol == ctx.definitions.Predef_undefined || rhs.tpe =:= ctx.definitions.NothingType || (rhs match {
+          case _: tpd.Literal => true
+          case _ => rhs.tpe.isInstanceOf[ConstantType]
+        })
+      def registerTrivial(using Context): Unit =
+        if defdef.isTrivial then
+          trivialDefs += defdef.symbol
+
   end UnusedData
 
   private object UnusedData:

tests/neg-custom-args/fatal-warnings/i15503e.scala

@@ -1,23 +1,27 @@
 // scalac: -Wunused:explicits
 
+/* This goes around the "trivial method" detection */
+val default_val = 1
+
 def f1(a: Int) = a // OK
-def f2(a: Int) = 1 // error
+def f2(a: Int) = default_val // error
 def f3(a: Int)(using Int) = a // OK
-def f4(a: Int)(using Int) = 1 // error
+def f4(a: Int)(using Int) = default_val // error
 def f6(a: Int)(using Int) = summon[Int] // error
 def f7(a: Int)(using Int) = summon[Int] + a // OK
 
-package scala2main:
+package scala2main.unused.args:
   object happyBirthday {
-    def main(args: Array[String]): Unit = ??? // error
+    def main(args: Array[String]): Unit = println("Hello World") // error
   }
 
-package scala2mainunused:
+package scala2main:
   object happyBirthday {
     def main(args: Array[String]): Unit = // OK
-      val a = args.size
-      ???
+      println(s"Hello World, there are ${args.size} arguments")
   }
 
 package scala3main:
-  @main def hello = ??? // OK
+  /* This goes around the "trivial method" detection */
+  val default_unit = ()
+  @main def hello = println("Hello World") // OK

tests/neg-custom-args/fatal-warnings/i15503f.scala

@@ -1,9 +1,12 @@
 // scalac: -Wunused:implicits
 
+/* This goes around the "trivial method" detection */
+val default_int = 1
+
 def f1(a: Int) = a // OK
 def f2(a: Int) = 1 // OK
 def f3(a: Int)(using Int) = a // error
-def f4(a: Int)(using Int) = 1 // error
+def f4(a: Int)(using Int) = default_int // error
 def f6(a: Int)(using Int) = summon[Int] // OK
 def f7(a: Int)(using Int) = summon[Int] + a // OK
 

tests/neg-custom-args/fatal-warnings/i15503g.scala

@@ -1,9 +1,15 @@
 // scalac: -Wunused:params
 
+/* This goes around the "trivial method" detection */
+val default_int = 1
+
 def f1(a: Int) = a // OK
-def f2(a: Int) = 1 // error
+def f2(a: Int) = default_int // error
 def f3(a: Int)(using Int) = a // error
-def f4(a: Int)(using Int) = 1 // error // error
+def f4(a: Int)(using Int) = default_int // error // error
 def f6(a: Int)(using Int) = summon[Int] // error
 def f7(a: Int)(using Int) = summon[Int] + a // OK
 
+/* --- Trivial method check --- */
+def g1(x: Int) = 1 // OK
+def g2(x: Int) = ??? // OK

tests/neg-custom-args/fatal-warnings/i15503h.scala

@@ -7,7 +7,7 @@ class A {
   val b = 2 // OK
 
   private def c = 2 // error
-  def d(using x:Int): Int = 1 // error
+  def d(using x:Int): Int = b // error
   def e(x: Int) = 1 // OK
   def f =
     val x = 1 // error

tests/neg-custom-args/fatal-warnings/i15503i.scala

@@ -7,16 +7,20 @@ class A {
   import collection.mutable.{Map => MutMap} // OK
   private val a = 1 // error
   val b = 2 // OK
+
+  /* This goes around the trivial method detection */
+  val default_int = 12
+
   val someMap = MutMap()
 
   private def c1 = 2 // error
   private def c2 = 2 // OK
   def c3 = c2
 
-  def d1(using x:Int): Int = 1 // error
+  def d1(using x:Int): Int = default_int // error
   def d2(using x:Int): Int = x // OK
 
-  def e1(x: Int) = 1 // error
+  def e1(x: Int) = default_int // error
   def e2(x: Int) = x // OK
   def f =
     val x = 1 // error
@@ -35,9 +39,12 @@ class A {
 package foo.test.scala.annotation:
   import annotation.unused // OK
 
+  /* This goes around the trivial method detection */
+  val default_int = 12
+
   def a1(a: Int) = a // OK
-  def a2(a: Int) = 1 // error
-  def a3(@unused a: Int) = 1 //OK
+  def a2(a: Int) = default_int // error
+  def a3(@unused a: Int) = default_int //OK
 
   def b1 =
     def f = 1 // error