Complete when improting same symbol multiple times

This is related to #13623 - since it seems that Predef might be imported more than once, but this doesn't yet solve the issue.

Author: tgodzik

compiler/src/dotty/tools/dotc/interactive/Completion.scala

@@ -201,13 +201,22 @@ object Completion {
 
       mappings.foreach { (name, denotss) =>
         val first = denotss.head
+
+        // import a.c
+        def isSingleImport =  denotss.length < 2
+        // import a.C
+        // locally {  import b.C }
+        def isImportedInDifferentScope =  first.ctx.scope ne denotss(1).ctx.scope
+        // import a.C
+        // import a.C
+        def isSameSymbolImportedDouble =  denotss.forall(_.denots == first.denots)
+
         denotss.find(!_.ctx.isImportContext) match {
           // most deeply nested member or local definition if not shadowed by an import
           case Some(local) if local.ctx.scope == first.ctx.scope =>
             resultMappings += name -> local.denots
 
-          // most deeply nested import if not shadowed by another import
-          case None if denotss.length < 2 || (denotss(1).ctx.scope ne first.ctx.scope) =>
+          case None if isSingleImport || isImportedInDifferentScope || isSameSymbolImportedDouble =>
             resultMappings += name -> first.denots
 
           case _ =>

language-server/test/dotty/tools/languageserver/CompletionTest.scala

@@ -404,6 +404,19 @@ class CompletionTest {
       .completion(m1, Set())
   }
 
+  @Test def completeFromSameImportsForEqualNestingLevels: Unit = {
+    code"""object Foo {
+          |  def xxxx(i: Int): Int = i
+          |}
+          |object Test {
+          |  import Foo.xxxx
+          |  import Foo.xxxx
+          |  import Foo.xxxx
+          |  val x = xx$m1
+          |}""".withSource
+      .completion(m1, Set(("xxxx", Method, "(i: Int): Int")))
+  }
+
   @Test def preferLocalDefinitionToImportForEqualNestingLevels: Unit = {
     code"""object Foo {
           |  val xxxx = 1