Adds * as default import group.

Author: wpopielarski

src/main/scala/scala/tools/refactoring/implementations/OrganizeImports.scala

@@ -12,34 +12,36 @@ import scala.tools.refactoring.sourcegen.Formatting
 import scala.util.control.NonFatal
 
 object OrganizeImports {
+  val DefaultGroup = "*"
   /**
    * Abstract algorithms used by the implementation, extracted mostly for testing purposes
    */
   private[implementations] object Algos {
     def groupImports[ImportT](getImportExpression: ImportT => String)(groups: Seq[String], imports: Seq[ImportT]): Seq[List[ImportT]] = {
       val distinctGroups = groups.distinct
-
-      case class Accumulator(remainingImports: Seq[ImportT] = imports, groups: Map[String, List[ImportT]] = Map()) {
-        def assembleResult: Seq[List[ImportT]] = {
-          val importGroups = distinctGroups.flatMap(groups.get(_))
-          if (remainingImports.isEmpty) importGroups
-          else importGroups :+ remainingImports.toList
-        }
-      }
-
-      distinctGroups.sortBy(-_.length).foldLeft(Accumulator()) { (acc, group) =>
-        val (inGroup, remaining) = acc.remainingImports.partition { imp =>
-          val expr = getImportExpression(imp)
+      val acc = distinctGroups.map(_ -> scala.collection.mutable.ListBuffer.empty[ImportT]).toMap
+      val assigned = imports.foldLeft(acc) { (acc, imp) =>
+        val expr = getImportExpression(imp)
+        val (inGroup, _) = distinctGroups.partition { group =>
           expr.startsWith(group + ".") || expr == group
         }
-
-        val newGroups = {
-          if (inGroup.isEmpty) acc.groups
-          else acc.groups + (group -> inGroup.toList)
+        if (inGroup.nonEmpty) {
+          val mostSpecificGroup = inGroup.sortBy(-_.length).head
+          acc(mostSpecificGroup) += imp
         }
-
-        acc.copy(remainingImports = remaining, groups = newGroups)
-      }.assembleResult
+        acc
+      }
+      val unassigned = {
+        val a = assigned.values.toList.flatten.map(getImportExpression)
+        val (_, unassigned) = imports.partition { imp => a.contains(getImportExpression(imp)) }
+        unassigned
+      }
+      if (assigned.keySet(DefaultGroup)) {
+        assigned(DefaultGroup) ++= unassigned
+        assigned.values.filter(_.nonEmpty).toSeq.map(_.toList)
+      } else {
+        assigned.values.filter(_.nonEmpty).toSeq.map(_.toList) :+ (unassigned.toList)
+      }
     }
   }
 

src/test/scala/scala/tools/refactoring/tests/implementations/imports/OrganizeImportsGroupsTest.scala

@@ -380,4 +380,48 @@ class OrganizeImportsGroupsTest extends OrganizeImportsBaseTest {
       }
     """
   } applyRefactoring organize(List("org", "scala", "java", "*"))
+
+  @Test
+  def mostSpecificTakesPrecedence() = new FileSet {
+    source becomes
+    """
+      import scala.io.Source
+
+      import scala.collection.mutable.HashMap
+      import scala.collection.mutable.ListBuffer
+
+      import java.util.AbstractList
+      import java.util.BitSet
+      import org.xml.sax.Attributes
+
+      trait Temp {
+        // we need some code that use the imports
+        val x: (ListBuffer[Int], HashMap[String, Int])
+        val y: (AbstractList[Int], BitSet)
+        val z: (Attributes, Source)
+      }
+    """
+  } applyRefactoring organize(List("scala", "scala.collection"))
+
+  @Test
+  def fromSpecificToGeneral() = new FileSet {
+    source becomes
+    """
+      import scala.io.Source
+
+      import scala.collection.mutable.HashMap
+      import scala.collection.mutable.ListBuffer
+
+      import java.util.AbstractList
+      import java.util.BitSet
+      import org.xml.sax.Attributes
+
+      trait Temp {
+        // we need some code that use the imports
+        val x: (ListBuffer[Int], HashMap[String, Int])
+        val y: (AbstractList[Int], BitSet)
+        val z: (Attributes, Source)
+      }
+    """
+  } applyRefactoring organize(List("scala.io", "scala"))
 }