Merge branch 'feature/linter/unused' of github.com:PaulCoral/dotty into feature/linter/unused

Author: PaulCoral

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

@@ -16,6 +16,11 @@ import dotty.tools.dotc.typer.ImportInfo
 import dotty.tools.dotc.util.Property
 import dotty.tools.dotc.transform.CheckUnused.UnusedData.UnusedResult
 import dotty.tools.dotc.core.Mode
+import dotty.tools.dotc.core.Types.TypeTraverser
+import dotty.tools.dotc.core.Types.Type
+import dotty.tools.dotc.core.Types.AnnotatedType
+import dotty.tools.dotc.core.Flags.flagsString
+import dotty.tools.dotc.core.Flags
 
 
 
@@ -64,13 +69,14 @@ class CheckUnused extends Phase:
       tree match
         case imp:tpd.Import =>
           unusedDataApply(_.registerImport(imp))
+          traverseChildren(tree)(using newCtx)
         case ident: Ident =>
           unusedDataApply(_.registerUsed(ident.symbol))
           traverseChildren(tree)(using newCtx)
         case sel: Select =>
           unusedDataApply(_.registerUsed(sel.symbol))
           traverseChildren(tree)(using newCtx)
-        case _: (tpd.Block | tpd.Template) =>
+        case _: (tpd.Block | tpd.Template | tpd.PackageDef) =>
           unusedDataApply { ud =>
             ud.inNewScope(ScopeType.fromTree(tree))(traverseChildren(tree)(using newCtx))
           }
@@ -83,11 +89,19 @@ class CheckUnused extends Phase:
         case t: tpd.Bind =>
           unusedDataApply(_.registerPatVar(t))
           traverseChildren(tree)(using newCtx)
+        case t@tpd.TypeTree() =>
+          typeTraverser(unusedDataApply).traverse(t.tpe)
+          traverseChildren(tree)(using newCtx)
         case _ =>
           traverseChildren(tree)(using newCtx)
     end traverse
   end traverser
 
+  private def typeTraverser(dt: (UnusedData => Any) => Unit)(using Context) = new TypeTraverser:
+    override def traverse(tp: Type): Unit = tp match
+      case AnnotatedType(_, annot) => dt(_.registerUsed(annot.symbol))
+      case _ => traverseChildren(tp)
+
   private def reportUnused(res: UnusedData.UnusedResult)(using Context): Unit =
     import CheckUnused.WarnTypes
     res.warnings.foreach { s =>
@@ -185,6 +199,8 @@ object CheckUnused:
       if !isConstructorOfSynth(sym) then
         usedInScope.top += sym -> sym.isAccessibleAsIdent
         usedDef += sym
+        if sym.isConstructor && sym.exists then
+          registerUsed(sym.owner) // constructor are "implicitly" imported with the class
 
     /** Register a list of found (used) symbols */
     def registerUsed(syms: Seq[Symbol])(using Context): Unit =
@@ -340,10 +356,10 @@ object CheckUnused:
       /** Given an import and accessibility, return an option of selector that match import<->symbol */
       def isInImport(imp: tpd.Import, isAccessible: Boolean)(using Context): Option[ImportSelector] =
         val tpd.Import(qual, sels) = imp
-        val qualHasSymbol = qual.tpe.member(sym.name).symbol == sym
+        val qualHasSymbol = qual.tpe.member(sym.name).alternatives.map(_.symbol).contains(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) || sym.is(Implicit)))
-        if qualHasSymbol && !isAccessible then
+        if qualHasSymbol && !isAccessible && sym.exists then
           selector.orElse(wildcard) // selector with name or wildcard (or given)
         else
           None

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

@@ -187,4 +187,53 @@ object Scala2ImplicitsGiven:
     val b = summon[Int]
   object G:
     import A.x  // error
-    val b = 1
+    val b = 1
+
+// -------------------------------------
+object TestNewKeyword:
+  object Foo:
+    class Aa[T](val x: T)
+  object Bar:
+    import Foo.Aa // OK
+    val v = 1
+    val a = new Aa(v)
+
+// -------------------------------------
+object testAnnotatedType:
+  import annotation.switch // OK
+  val a = (??? : @switch) match
+    case _ => ???
+
+
+//-------------------------------------
+package testImportsInImports:
+  package a:
+    package b:
+      val x = 1
+  package c:
+    import a.b // OK
+    import b.x // OK
+    val y = x
+
+//-------------------------------------
+package testOnOverloadedMethodsImports:
+  package a:
+    trait A
+    trait B
+    trait C:
+      def foo(x: A):A = ???
+      def foo(x: B):B = ???
+  package b:
+    object D extends a.C
+  package c:
+    import b.D.foo // error
+  package d:
+    import b.D.foo // OK
+    def bar = foo((??? : a.A))
+  package e:
+    import b.D.foo // OK
+    def bar = foo((??? : a.B))
+  package f:
+    import b.D.foo // OK
+    def bar = foo((??? : a.A))
+    def baz = foo((??? : a.B))