Remove report unused implicit imports

- Named import pointing to an implicit
- Given imports `import foo.bar.given`
- Add new tests, remove the ones on implicit reporting

Author: PaulCoral

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

@@ -192,9 +192,12 @@ object CheckUnused:
 
     /** Register an import */
     def registerImport(imp: tpd.Import)(using Context): Unit =
-      if !tpd.languageImport(imp.expr).nonEmpty then
+      val tpd.Import(qual, selectors) = imp
+      if !tpd.languageImport(qual).nonEmpty then
         impInScope.top += imp
-        unusedImport ++= imp.selectors.filter(s => !isImportExclusion(s))
+        unusedImport ++= selectors.filter{ s =>
+          !isImportExclusion(s) && !s.isGiven && !isSelectorOnAGiven(qual, s)
+        }
 
     /** Register (or not) some `val` or `def` according to the context, scope and flags */
     def registerDef(valOrDef: tpd.ValOrDefDef)(using Context): Unit =
@@ -293,6 +296,9 @@ 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))
+
     private def isImportExclusion(sel: ImportSelector): Boolean = sel.renamed match
       case untpd.Ident(name) => name == StdNames.nme.WILDCARD
       case _ => false

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

@@ -31,14 +31,6 @@ 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
@@ -92,12 +84,6 @@ 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 {
@@ -115,9 +101,10 @@ package p {
 /* END : Check on packages*/
 
 /* BEGIN : tests on meta-language features */
-object TestGivenCoversionScala2:
+object TestLanguageImportAreIgnored:
   /* 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
 
@@ -153,4 +140,43 @@ object GivenImportOrderBtoA:
     import A._ // error
     def t = implicitly[X]
   }
-/* END : tests on given import order */
+/* 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