Revert to unused implicit check, also synthetics

- Check implicit and given imports
- Adapt check to some synthetic (@main, package object)
- Add new tests to support these features

Author: PaulCoral

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

@@ -7,7 +7,7 @@ import dotty.tools.dotc.ast.untpd.ImportSelector
 import dotty.tools.dotc.config.ScalaSettings
 import dotty.tools.dotc.core.Contexts.*
 import dotty.tools.dotc.core.Decorators.{em, i}
-import dotty.tools.dotc.core.Flags.{Given, GivenVal, Param, Private, SelfName}
+import dotty.tools.dotc.core.Flags.{Given, Implicit, GivenOrImplicit, Param, Private, SelfName, Synthetic}
 import dotty.tools.dotc.core.Phases.Phase
 import dotty.tools.dotc.core.StdNames
 import dotty.tools.dotc.report
@@ -182,27 +182,25 @@ object CheckUnused:
 
     /** Register a found (used) symbol */
     def registerUsed(sym: Symbol)(using Context): Unit =
-      usedInScope.top += sym -> sym.isAccessibleAsIdent
-      usedDef += sym
+      if !isConstructorOfSynth(sym) then
+        usedInScope.top += sym -> sym.isAccessibleAsIdent
+        usedDef += sym
 
     /** Register a list of found (used) symbols */
     def registerUsed(syms: Seq[Symbol])(using Context): Unit =
-      usedInScope.top ++= syms.map(s => s -> s.isAccessibleAsIdent)
+      usedInScope.top ++= syms.filterNot(isConstructorOfSynth).map(s => s -> s.isAccessibleAsIdent)
       usedDef ++= syms
 
     /** Register an import */
     def registerImport(imp: tpd.Import)(using Context): Unit =
-      val tpd.Import(qual, selectors) = imp
-      if !tpd.languageImport(qual).nonEmpty then
+      if !tpd.languageImport(imp.expr).nonEmpty then
         impInScope.top += imp
-        unusedImport ++= selectors.filter{ s =>
-          !isImportExclusion(s) && !s.isGiven && !isSelectorOnAGiven(qual, s)
-        }
+        unusedImport ++= imp.selectors.filter(s => !isImportExclusion(s))
 
     /** Register (or not) some `val` or `def` according to the context, scope and flags */
     def registerDef(valOrDef: tpd.ValOrDefDef)(using Context): Unit =
-      if valOrDef.symbol.is(Param) then
-        if valOrDef.symbol.is(Given) then
+      if valOrDef.symbol.is(Param) && !isSyntheticMainParam(valOrDef.symbol) then
+        if valOrDef.symbol.isOneOf(GivenOrImplicit) then
           implicitParamInScope += valOrDef
         else
           explicitParamInScope += valOrDef
@@ -296,8 +294,33 @@ object CheckUnused:
     end getUnused
     //============================ HELPERS ====================================
 
-    private def isSelectorOnAGiven(qual: tpd.Tree, sel: ImportSelector)(using Context): Boolean =
-      qual.tpe.member(sel.name).alternatives.exists(_.symbol.is(Given))
+    /**
+     * Is the the constructor of synthetic package object
+     * Should be ignored as it is always imported/used in package
+     * Trigger false negative on used import
+     *
+     * Without this check example:
+     *
+     * --- WITH PACKAGE : WRONG ---
+     * {{{
+     * package a:
+     *   val x: Int = 0
+     * package b:
+     *   import a._ // no warning
+     * }}}
+     * --- WITH OBJECT : OK ---
+     * {{{
+     * object a:
+     *   val x: Int = 0
+     * object b:
+     *   import a._ // unused warning
+     * }}}
+     */
+    private def isConstructorOfSynth(sym: Symbol)(using Context): Boolean =
+      sym.exists && sym.isConstructor && sym.owner.isPackageObject && sym.owner.is(Synthetic)
+
+    private def isSyntheticMainParam(sym: Symbol)(using Context): Boolean =
+      sym.exists && ctx.platform.isMainMethod(sym.owner) && sym.owner.is(Synthetic)
 
     private def isImportExclusion(sel: ImportSelector): Boolean = sel.renamed match
       case untpd.Ident(name) => name == StdNames.nme.WILDCARD
@@ -319,7 +342,7 @@ object CheckUnused:
         val tpd.Import(qual, sels) = imp
         val qualHasSymbol = qual.tpe.member(sym.name).symbol == sym
         def selector = sels.find(sel => sel.name.toTermName == sym.name || sel.name.toTypeName == sym.name)
-        def wildcard = sels.find(sel => sel.isWildcard && (sym.is(Given) == sel.isGiven))
+        def wildcard = sels.find(sel => sel.isWildcard && ((sym.is(Given) == sel.isGiven) || sym.is(Implicit)))
         if qualHasSymbol && !isAccessible then
           selector.orElse(wildcard) // selector with name or wildcard (or given)
         else

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

@@ -31,6 +31,14 @@ object FooNested:
   object Nested:
     def hello = Set()
 
+object FooGivenUnused:
+  import SomeGivenImports.given // error
+
+object FooGiven:
+  import SomeGivenImports.given // OK
+  import SomeGivenImports._ // error
+
+  val foo = summon[Int]
 
 /**
  * Import used as type name are considered
@@ -84,27 +92,43 @@ object IgnoreExclusion:
   def check =
     val a = Set(1)
     val b = Map(1 -> 2)
+/**
+  * Some given values for the test
+  */
+object SomeGivenImports:
+  given Int = 0
+  given String = "foo"
 
 /* BEGIN : Check on packages*/
-package p {
-  class C
-}
-
-package p {
-  import p._ // error
-  package q {
-    class U {
-      def f = new C
+package testsamepackageimport:
+  package p {
+    class C
+  }
+
+  package p {
+    import p._ // error
+    package q {
+      class U {
+        def f = new C
+      }
     }
   }
-}
+// -----------------------
+
+package testpackageimport:
+  package a:
+    val x: Int = 0
+
+  package b:
+    import a._ // error
+
+
 /* END : Check on packages*/
 
 /* BEGIN : tests on meta-language features */
-object TestLanguageImportAreIgnored:
+object TestGivenCoversionScala2:
   /* note: scala3 Conversion[U,T] do not require an import */
   import language.implicitConversions // OK
-  import language._ // OK
 
   implicit def doubleToInt(d:Double):Int = d.toInt
 
@@ -126,7 +150,7 @@ object GivenImportOrderAtoB:
   object B { implicit val y: Y = new Y }
   class C {
     import A._ // error
-    import B._
+    import B._ // OK
     def t = implicitly[X]
   }
 
@@ -136,47 +160,31 @@ object GivenImportOrderBtoA:
   object A { implicit val x: X = new X }
   object B { implicit val y: Y = new Y }
   class C {
-    import B._
+    import B._ // OK
     import A._ // error
     def t = implicitly[X]
   }
 /* END : tests on given import order */
 
-/*
- * Advanced tests on given imports meta-programming
- *
- * - Currently also tests that no imported implicits are reported
- */
-
-package summoninlineconflict:
-  package lib:
-    trait A
-    trait B
-    trait C
-    trait X
-
-    given willBeUnused: (A & X) = new A with X {}
-    given willBeUsed: (A & B) = new A with B {}
-    given notUsedAtAll: Int = 0
-
-  package use:
-    import lib.{A, B, C, willBeUnused, willBeUsed, notUsedAtAll} // OK
-    import compiletime.summonInline // OK
-
-    transparent inline given conflictInside: C =
-      summonInline[A]
-      new {}
-
-    transparent inline given potentialConflict: C =
-      summonInline[B]
-      new {}
-
-    val b: B = summon[B]
-    val c: C = summon[C]
-
-package unusedgivensimports:
-  package foo:
-    given Int = 0
-
-  package bar:
-    import foo.given // OK
+/* Scala 2 implicits */
+object Scala2ImplicitsGiven:
+  object A:
+    implicit val x: Int = 1
+  object B:
+    import A.given  // OK
+    val b = summon[Int]
+  object C:
+    import A.given  // error
+    val b = 1
+  object D:
+    import A._  // OK
+    val b = summon[Int]
+  object E:
+    import A._  // error
+    val b = 1
+  object F:
+    import A.x  // OK
+    val b = summon[Int]
+  object G:
+    import A.x  // error
+    val b = 1

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

@@ -5,4 +5,19 @@ def f2(a: Int) = 1 // error
 def f3(a: Int)(using Int) = a // OK
 def f4(a: Int)(using Int) = 1 // error
 def f6(a: Int)(using Int) = summon[Int] // error
-def f7(a: Int)(using Int) = summon[Int] + a // OK
+def f7(a: Int)(using Int) = summon[Int] + a // OK
+
+package scala2main:
+  object happyBirthday {
+    def main(args: Array[String]): Unit = ??? // error
+  }
+
+package scala2mainunused:
+  object happyBirthday {
+    def main(args: Array[String]): Unit = // OK
+      val a = args.size
+      ???
+  }
+
+package scala3main:
+  @main def hello = ??? // OK