Rewrite JavaConversions => JavaConverters (fix #92)

Author: MasseGuillaume

build.sbt

@@ -87,6 +87,14 @@ lazy val sharedScalafixSettings = Seq(
   )
 )
 
+// common part between input/output
+lazy val scalafixData = project
+  .in(file("scalafix/data"))
+  .settings(sharedScalafixSettings)
+  .settings(dontPublish)
+  .settings(scalaVersion := scalafixScala212)
+  .dependsOn(compatJVM)
+
 lazy val scalafixInput = project
   .in(file("scalafix/input"))
   .settings(sharedScalafixSettings)
@@ -95,14 +103,14 @@ lazy val scalafixInput = project
     scalaVersion := scalafixScala212,
     scalafixSourceroot := sourceDirectory.in(Compile).value
   )
-  .dependsOn(compatJVM)
+  .dependsOn(compatJVM, scalafixData)
 
 lazy val scalafixOutput212 = project
   .in(file("scalafix/output212"))
   .settings(sharedScalafixSettings)
   .settings(scalaVersion := scalafixScala212)
   .settings(dontPublish)
-  .dependsOn(compatJVM)
+  .dependsOn(compatJVM, scalafixData)
 
 lazy val scalafixOutput213 = project
   .in(file("scalafix/output213"))

scalafix/data/src/main/scala/fix/conversions/JavaConversionsDataSrc.scala

@@ -0,0 +1,19 @@
+package fix.conversions
+
+import scala.collection.{immutable => i, mutable => m, concurrent => conc}
+import java.{ lang => jl, util => ju }, java.util.{ concurrent => juc }
+
+trait JavaConversionsDataSrc {
+  val iterable = List(1).toIterable
+  val concMap: conc.Map[Int, Int] = ???
+  val juIterator       : ju.Iterator[Int]            = ???
+  val juEnumeration    : ju.Enumeration[Int]         = ???
+  val jlIterable       : jl.Iterable[Int]            = ???
+  val juCollection     : ju.Collection[Int]          = ???
+  val juList           : ju.List[Int]                = ???
+  val juSet            : ju.Set[Int]                 = ???
+  val juMap            : ju.Map[Int, Int]            = ???
+  val jucConcurrentMap : juc.ConcurrentMap[Int, Int] = ???
+  val juDictionary     : ju.Dictionary[Int, Int]     = ???
+  val juProperties     : ju.Properties               = ???
+}

scalafix/input/src/main/scala/fix/conversions/JavaConversionsExplicitCallSrc.scala

@@ -0,0 +1,85 @@
+/*
+rule = "scala:fix.CrossCompat"
+ */
+package fix.conversions
+
+import scala.collection.{immutable => i, mutable => m, concurrent => conc}
+import java.{ lang => jl, util => ju }, java.util.{ concurrent => juc }
+import scala.collection.JavaConversions._
+
+object JavaConversionsExplicitCallSrc extends JavaConversionsDataSrc {
+
+  // ### Scala => Java ###
+
+  // asJavaIterator
+  asJavaIterator(Iterator(1)): ju.Iterator[Int]
+
+  // asJavaEnumeration
+  asJavaEnumeration(Iterator(1)): ju.Enumeration[Int]
+
+  // asJavaIterable
+  asJavaIterable(iterable): jl.Iterable[Int]
+
+  // asJavaCollection
+  asJavaCollection(iterable): ju.Collection[Int]
+
+  // bufferAsJavaList
+  bufferAsJavaList(m.Buffer(1)): ju.List[Int]
+
+  // mutableSeqAsJavaList
+  mutableSeqAsJavaList(m.Seq(1)): ju.List[Int]
+
+  // seqAsJavaList
+  seqAsJavaList(Seq(1)): ju.List[Int]
+
+  // mutableSetAsJavaSet
+  mutableSetAsJavaSet(m.Set(1)): ju.Set[Int]
+
+  // setAsJavaSet
+  setAsJavaSet(Set(1)): ju.Set[Int]
+
+  // mutableMapAsJavaMap
+  mutableMapAsJavaMap(m.Map(1 -> 1)): ju.Map[Int, Int]
+
+  // asJavaDictionary
+  asJavaDictionary(m.Map(1 -> 1)): ju.Dictionary[Int, Int]
+
+  // mapAsJavaMap
+  mapAsJavaMap(m.Map(1 -> 1)): ju.Map[Int, Int]
+
+  // mapAsJavaConcurrentMap
+  mapAsJavaConcurrentMap(concMap): juc.ConcurrentMap[Int, Int]
+
+
+  // ### Java => Scala ###
+
+  // asScalaIterator
+  asScalaIterator(juIterator): Iterator[Int]
+
+  // enumerationAsScalaIterator
+  enumerationAsScalaIterator(juEnumeration): Iterator[Int]
+
+  // iterableAsScalaIterable
+  iterableAsScalaIterable(jlIterable): Iterable[Int]
+
+  // collectionAsScalaIterable
+  collectionAsScalaIterable(juCollection): Iterable[Int]
+
+  // asScalaBuffer
+  asScalaBuffer(juList): m.Buffer[Int]
+
+  // asScalaSet
+  asScalaSet(juSet): m.Set[Int]
+
+  // mapAsScalaMap
+  mapAsScalaMap(juMap): m.Map[Int, Int]
+
+  // mapAsScalaConcurrentMap
+  mapAsScalaConcurrentMap(jucConcurrentMap): conc.Map[Int, Int]
+
+  // dictionaryAsScalaMap
+  dictionaryAsScalaMap(juDictionary): m.Map[Int, Int]
+
+  // propertiesAsScalaMap
+  propertiesAsScalaMap(juProperties): m.Map[String, String]
+}

scalafix/input/src/main/scala/fix/conversions/JavaConversionsGlobalImportSrc.scala

@@ -0,0 +1,85 @@
+/*
+rule = "scala:fix.CrossCompat"
+ */
+package fix.conversions
+
+import scala.collection.{immutable => i, mutable => m, concurrent => conc}
+import java.{ lang => jl, util => ju }, java.util.{ concurrent => juc }
+import scala.collection.JavaConversions._
+
+object JavaConversionsGlobalImportSrc extends JavaConversionsDataSrc {
+
+  // ### Scala => Java ###
+
+  // asJavaIterator
+  Iterator(1): ju.Iterator[Int]
+
+  // asJavaEnumeration
+  Iterator(1): ju.Enumeration[Int]
+
+  // ambigous: asJavaIterable
+  // iterable: jl.Iterable[Int]
+
+  // asJavaCollection
+  iterable: ju.Collection[Int]
+
+  // bufferAsJavaList
+  m.Buffer(1): ju.List[Int]
+
+  // mutableSeqAsJavaList
+  m.Seq(1): ju.List[Int]
+
+  // seqAsJavaList
+  Seq(1): ju.List[Int]
+
+  // mutableSetAsJavaSet
+  m.Set(1): ju.Set[Int]
+
+  // setAsJavaSet
+  Set(1): ju.Set[Int]
+
+  // mutableMapAsJavaMap
+  m.Map(1 -> 1): ju.Map[Int, Int]
+
+  // asJavaDictionary
+  m.Map(1 -> 1): ju.Dictionary[Int, Int]
+
+  // mapAsJavaMap
+  m.Map(1 -> 1): ju.Map[Int, Int]
+
+  // mapAsJavaConcurrentMap
+  concMap: juc.ConcurrentMap[Int, Int]
+
+
+  // ### Java => Scala ###
+
+  // asScalaIterator
+  juIterator: Iterator[Int]
+
+  // enumerationAsScalaIterator
+  juEnumeration: Iterator[Int]
+
+  // iterableAsScalaIterable
+  jlIterable: Iterable[Int]
+
+  // collectionAsScalaIterable
+  juCollection: Iterable[Int]
+
+  // asScalaBuffer
+  juList: m.Buffer[Int]
+
+  // asScalaSet
+  juSet: m.Set[Int]
+
+  // mapAsScalaMap
+  juMap: m.Map[Int, Int]
+
+  // mapAsScalaConcurrentMap
+  jucConcurrentMap: conc.Map[Int, Int]
+
+  // dictionaryAsScalaMap
+  juDictionary: m.Map[Int, Int]
+
+  // propertiesAsScalaMap
+  juProperties: m.Map[String, String]
+}

scalafix/input/src/main/scala/fix/conversions/JavaConversionsSpecificImportSrc.scala

@@ -0,0 +1,154 @@
+/*
+rule = "scala:fix.CrossCompat"
+ */
+package fix.conversions
+
+import scala.collection.{immutable => i, mutable => m, concurrent => conc}
+import java.{ lang => jl, util => ju }, java.util.{ concurrent => juc }
+import scala.collection.JavaConversions
+
+object JavaConversionsSpecificImportSrc extends JavaConversionsDataSrc {
+
+  // ### Scala => Java ###
+
+  // asJavaIterator
+  {
+    import JavaConversions.asJavaIterator
+    Iterator(1): ju.Iterator[Int]
+  }
+
+  // asJavaEnumeration
+  {
+    import JavaConversions.asJavaEnumeration
+    Iterator(1): ju.Enumeration[Int]
+  }
+
+  // asJavaIterable
+  {
+    import JavaConversions.asJavaIterable
+    iterable: jl.Iterable[Int]
+  }
+
+  // asJavaCollection
+  {
+    import JavaConversions.asJavaCollection
+    iterable: ju.Collection[Int]
+  }
+
+  // bufferAsJavaList
+  {
+    import JavaConversions.bufferAsJavaList
+    m.Buffer(1): ju.List[Int]
+  }
+
+  // mutableSeqAsJavaList
+  {
+    import JavaConversions.mutableSeqAsJavaList
+    m.Seq(1): ju.List[Int]
+  }
+
+  // seqAsJavaList
+  {
+    import JavaConversions.seqAsJavaList
+    Seq(1): ju.List[Int]
+  }
+
+  // mutableSetAsJavaSet
+  {
+    import JavaConversions.mutableSetAsJavaSet
+    m.Set(1): ju.Set[Int]
+  }
+
+  // setAsJavaSet
+  {
+    import JavaConversions.setAsJavaSet
+    Set(1): ju.Set[Int]
+  }
+
+  // mutableMapAsJavaMap
+  {
+    import JavaConversions.mutableMapAsJavaMap
+    m.Map(1 -> 1): ju.Map[Int, Int]
+  }
+
+  // asJavaDictionary
+  {
+    import JavaConversions.asJavaDictionary
+    m.Map(1 -> 1): ju.Dictionary[Int, Int]
+  }
+
+  // mapAsJavaMap
+  {
+    import JavaConversions.mapAsJavaMap
+    m.Map(1 -> 1): ju.Map[Int, Int]
+  }
+
+  // mapAsJavaConcurrentMap
+  {
+    import JavaConversions.mapAsJavaConcurrentMap
+    concMap: juc.ConcurrentMap[Int, Int]
+  }
+
+
+  // ### Java => Scala ###
+
+  // asScalaIterator
+  {
+    import JavaConversions.asScalaIterator
+    juIterator: Iterator[Int]
+  }
+
+  // enumerationAsScalaIterator
+  {
+    import JavaConversions.enumerationAsScalaIterator
+    juEnumeration: Iterator[Int]
+  }
+
+  // iterableAsScalaIterable
+  {
+    import JavaConversions.iterableAsScalaIterable
+    jlIterable: Iterable[Int]
+  }
+
+  // collectionAsScalaIterable
+  {
+    import JavaConversions.collectionAsScalaIterable
+    juCollection: Iterable[Int]
+  }
+
+  // asScalaBuffer
+  {
+    import JavaConversions.asScalaBuffer
+    juList: m.Buffer[Int]
+  }
+
+  // asScalaSet
+  {
+    import JavaConversions.asScalaSet
+    juSet: m.Set[Int]
+  }
+
+  // mapAsScalaMap
+  {
+    import JavaConversions.mapAsScalaMap
+    juMap: m.Map[Int, Int]
+  }
+
+  // mapAsScalaConcurrentMap
+  {
+    import JavaConversions.mapAsScalaConcurrentMap
+    jucConcurrentMap: conc.Map[Int, Int]
+  }
+
+  // dictionaryAsScalaMap
+  {
+    import JavaConversions.dictionaryAsScalaMap
+    juDictionary: m.Map[Int, Int]
+  }
+
+  // propertiesAsScalaMap
+  {
+    import JavaConversions.propertiesAsScalaMap
+    juProperties: m.Map[String, String]
+  }
+}