From e49a918c52b29c59d73445dec7546da47843a751 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Guillaume=20Mass=C3=A9?= Date: Wed, 1 Aug 2018 11:12:58 +0200 Subject: [PATCH 1/8] Simplify cross-compilation for scalafix output --- build.sbt | 13 ++++++------- 1 file changed, 6 insertions(+), 7 deletions(-) diff --git a/build.sbt b/build.sbt index b76bda0c..3fe7f7e9 100644 --- a/build.sbt +++ b/build.sbt @@ -182,15 +182,13 @@ val `scalafix-output` = MultiScalaProject("scalafix-output", .settings(dontPublish) .disablePlugins(ScalafixPlugin)) -lazy val output212 = Def.setting((baseDirectory in ThisBuild).value / "scalafix/output212/src/main") -lazy val addOutput212 = unmanagedSourceDirectories in Compile += output212.value / "scala" - +lazy val addOutput212 = unmanagedSourceDirectories in Compile += output212.value / "scala" +lazy val addOutput212Plus = unmanagedSourceDirectories in Compile += output212Plus.value / "scala" +lazy val addOutput213 = unmanagedSourceDirectories in Compile += output213.value / "scala" +lazy val output212 = Def.setting((baseDirectory in ThisBuild).value / "scalafix/output212/src/main") lazy val output212Plus = Def.setting((baseDirectory in ThisBuild).value / "scalafix/output212+/src/main") -lazy val addOutput212Plus = unmanagedSourceDirectories in Compile += output212Plus.value / "scala" - -lazy val output213 = Def.setting((baseDirectory in ThisBuild).value / "scalafix/output213/src/main") -lazy val addOutput213 = unmanagedSourceDirectories in Compile += output213.value / "scala" +lazy val output213 = Def.setting((baseDirectory in ThisBuild).value / "scalafix/output213/src/main") lazy val `scalafix-output211` = `scalafix-output`( scala211, @@ -232,6 +230,7 @@ lazy val `scalafix-tests` = project "output212Sourceroot" -> output212.value, "output212PlusSourceroot" -> output212Plus.value, "output213Sourceroot" -> output213.value, + "output212PlusSourceroot" -> output212Plus.value, "output213FailureSourceroot" -> sourceDirectory .in(`scalafix-output213-failure`, Compile) .value, From 39a3213c6a53c401086b59715dc40e93bb73f7fe Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Guillaume=20Mass=C3=A9?= Date: Wed, 1 Aug 2018 11:08:04 +0200 Subject: [PATCH 2/8] Implement experimental rule for unordering operation on Ordered collections in 2.12 a Ordered collection like SortedSet looses it's ordering on certain operation like map, when the result does not have an ordering. --- .../collection/compat/PackageShared.scala | 63 +++++----- .../scala/collection/compat/package.scala | 2 +- .../collection/compat/PackageShared0.scala | 83 +++++++++++++ .../main/scala-2.12+/fix/Data212Plus.scala | 8 ++ scalafix/data/src/main/scala/fix/Data.scala | 35 ++++++ .../src/main/scala/fix/UnsortedSrc.scala | 68 +++++++++++ .../main/scala/fix/UnsortedSrc212Plus.scala | 15 +++ .../src/main/scala/fix/UnsortedSrc.scala | 69 +++++++++++ .../main/scala/fix/UnsortedSrc212Plus.scala | 16 +++ .../src/main/scala/fix/Experimental.scala | 114 +++++++++++++++++- .../src/main/scala/fix/TypeMatcher.scala | 4 +- 11 files changed, 437 insertions(+), 40 deletions(-) create mode 100644 compat/src/main/scala/scala/collection/compat/PackageShared0.scala create mode 100644 scalafix/data/src/main/scala-2.12+/fix/Data212Plus.scala create mode 100644 scalafix/data/src/main/scala/fix/Data.scala create mode 100644 scalafix/input/src/main/scala/fix/UnsortedSrc.scala create mode 100644 scalafix/input/src/main/scala/fix/UnsortedSrc212Plus.scala create mode 100644 scalafix/output/src/main/scala/fix/UnsortedSrc.scala create mode 100644 scalafix/output212+/src/main/scala/fix/UnsortedSrc212Plus.scala diff --git a/compat/src/main/scala-2.11_2.12/scala/collection/compat/PackageShared.scala b/compat/src/main/scala-2.11_2.12/scala/collection/compat/PackageShared.scala index 04073951..896da9c2 100644 --- a/compat/src/main/scala-2.11_2.12/scala/collection/compat/PackageShared.scala +++ b/compat/src/main/scala-2.11_2.12/scala/collection/compat/PackageShared.scala @@ -7,7 +7,7 @@ import scala.collection.{immutable => i, mutable => m} import scala.{collection => c} /** The collection compatibility API */ -private[compat] trait PackageShared { +private[compat] trait PackageShared extends PackageShared0 { import CompatImpl._ /** @@ -97,36 +97,35 @@ private[compat] trait PackageShared { builder.result() } - implicit def toImmutableSortedMapExtensions( - fact: i.SortedMap.type): ImmutableSortedMapExtensions = - new ImmutableSortedMapExtensions(fact) + implicit def toImmutableSortedMapCompanionExtensions(fact: i.SortedMap.type): ImmutableSortedMapCompanionExtensions = + new ImmutableSortedMapCompanionExtensions(fact) - implicit def toImmutableListMapExtensions(fact: i.ListMap.type): ImmutableListMapExtensions = - new ImmutableListMapExtensions(fact) + implicit def toImmutableListMapCompanionExtensions(fact: i.ListMap.type): ImmutableListMapCompanionExtensions = + new ImmutableListMapCompanionExtensions(fact) - implicit def toImmutableHashMapExtensions(fact: i.HashMap.type): ImmutableHashMapExtensions = - new ImmutableHashMapExtensions(fact) + implicit def toImmutableHashMapCompanionExtensions(fact: i.HashMap.type): ImmutableHashMapCompanionExtensions = + new ImmutableHashMapCompanionExtensions(fact) - implicit def toImmutableTreeMapExtensions(fact: i.TreeMap.type): ImmutableTreeMapExtensions = - new ImmutableTreeMapExtensions(fact) + implicit def toImmutableTreeMapCompanionExtensions(fact: i.TreeMap.type): ImmutableTreeMapCompanionExtensions = + new ImmutableTreeMapCompanionExtensions(fact) - implicit def toImmutableIntMapExtensions(fact: i.IntMap.type): ImmutableIntMapExtensions = - new ImmutableIntMapExtensions(fact) + implicit def toImmutableIntMapCompanionExtensions(fact: i.IntMap.type): ImmutableIntMapCompanionExtensions = + new ImmutableIntMapCompanionExtensions(fact) - implicit def toImmutableLongMapExtensions(fact: i.LongMap.type): ImmutableLongMapExtensions = - new ImmutableLongMapExtensions(fact) + implicit def toImmutableLongMapCompanionExtensions(fact: i.LongMap.type): ImmutableLongMapCompanionExtensions = + new ImmutableLongMapCompanionExtensions(fact) - implicit def toMutableLongMapExtensions(fact: m.LongMap.type): MutableLongMapExtensions = - new MutableLongMapExtensions(fact) + implicit def toMutableLongMapCompanionExtensions(fact: m.LongMap.type): MutableLongMapCompanionExtensions = + new MutableLongMapCompanionExtensions(fact) - implicit def toMutableHashMapExtensions(fact: m.HashMap.type): MutableHashMapExtensions = - new MutableHashMapExtensions(fact) + implicit def toMutableHashMapCompanionExtensions(fact: m.HashMap.type): MutableHashMapCompanionExtensions = + new MutableHashMapCompanionExtensions(fact) - implicit def toMutableListMapExtensions(fact: m.ListMap.type): MutableListMapExtensions = - new MutableListMapExtensions(fact) + implicit def toMutableListMapCompanionExtensions(fact: m.ListMap.type): MutableListMapCompanionExtensions = + new MutableListMapCompanionExtensions(fact) - implicit def toMutableMapExtensions(fact: m.Map.type): MutableMapExtensions = - new MutableMapExtensions(fact) + implicit def toMutableMapCompanionExtensions(fact: m.Map.type): MutableMapCompanionExtensions = + new MutableMapCompanionExtensions(fact) implicit def toStreamExtensionMethods[A](stream: Stream[A]): StreamExtensionMethods[A] = new StreamExtensionMethods[A](stream) @@ -152,52 +151,52 @@ private[compat] trait PackageShared { val IterableOnce = c.TraversableOnce } -class ImmutableSortedMapExtensions(private val fact: i.SortedMap.type) extends AnyVal { +class ImmutableSortedMapCompanionExtensions(private val fact: i.SortedMap.type) extends AnyVal { def from[K: Ordering, V](source: TraversableOnce[(K, V)]): i.SortedMap[K, V] = build(i.SortedMap.newBuilder[K, V], source) } -class ImmutableListMapExtensions(private val fact: i.ListMap.type) extends AnyVal { +class ImmutableListMapCompanionExtensions(private val fact: i.ListMap.type) extends AnyVal { def from[K, V](source: TraversableOnce[(K, V)]): i.ListMap[K, V] = build(i.ListMap.newBuilder[K, V], source) } -class ImmutableHashMapExtensions(private val fact: i.HashMap.type) extends AnyVal { +class ImmutableHashMapCompanionExtensions(private val fact: i.HashMap.type) extends AnyVal { def from[K, V](source: TraversableOnce[(K, V)]): i.HashMap[K, V] = build(i.HashMap.newBuilder[K, V], source) } -class ImmutableTreeMapExtensions(private val fact: i.TreeMap.type) extends AnyVal { +class ImmutableTreeMapCompanionExtensions(private val fact: i.TreeMap.type) extends AnyVal { def from[K: Ordering, V](source: TraversableOnce[(K, V)]): i.TreeMap[K, V] = build(i.TreeMap.newBuilder[K, V], source) } -class ImmutableIntMapExtensions(private val fact: i.IntMap.type) extends AnyVal { +class ImmutableIntMapCompanionExtensions(private val fact: i.IntMap.type) extends AnyVal { def from[V](source: TraversableOnce[(Int, V)]): i.IntMap[V] = build(i.IntMap.canBuildFrom[Int, V](), source) } -class ImmutableLongMapExtensions(private val fact: i.LongMap.type) extends AnyVal { +class ImmutableLongMapCompanionExtensions(private val fact: i.LongMap.type) extends AnyVal { def from[V](source: TraversableOnce[(Long, V)]): i.LongMap[V] = build(i.LongMap.canBuildFrom[Long, V](), source) } -class MutableLongMapExtensions(private val fact: m.LongMap.type) extends AnyVal { +class MutableLongMapCompanionExtensions(private val fact: m.LongMap.type) extends AnyVal { def from[V](source: TraversableOnce[(Long, V)]): m.LongMap[V] = build(m.LongMap.canBuildFrom[Long, V](), source) } -class MutableHashMapExtensions(private val fact: m.HashMap.type) extends AnyVal { +class MutableHashMapCompanionExtensions(private val fact: m.HashMap.type) extends AnyVal { def from[K, V](source: TraversableOnce[(K, V)]): m.HashMap[K, V] = build(m.HashMap.canBuildFrom[K, V](), source) } -class MutableListMapExtensions(private val fact: m.ListMap.type) extends AnyVal { +class MutableListMapCompanionExtensions(private val fact: m.ListMap.type) extends AnyVal { def from[K, V](source: TraversableOnce[(K, V)]): m.ListMap[K, V] = build(m.ListMap.canBuildFrom[K, V](), source) } -class MutableMapExtensions(private val fact: m.Map.type) extends AnyVal { +class MutableMapCompanionExtensions(private val fact: m.Map.type) extends AnyVal { def from[K, V](source: TraversableOnce[(K, V)]): m.Map[K, V] = build(m.Map.canBuildFrom[K, V](), source) } diff --git a/compat/src/main/scala-2.13/scala/collection/compat/package.scala b/compat/src/main/scala-2.13/scala/collection/compat/package.scala index c324fc37..5e68c66d 100644 --- a/compat/src/main/scala-2.13/scala/collection/compat/package.scala +++ b/compat/src/main/scala-2.13/scala/collection/compat/package.scala @@ -1,6 +1,6 @@ package scala.collection -package object compat { +package object compat extends PackageShared0 { type Factory[-A, +C] = scala.collection.Factory[A, C] val Factory = scala.collection.Factory diff --git a/compat/src/main/scala/scala/collection/compat/PackageShared0.scala b/compat/src/main/scala/scala/collection/compat/PackageShared0.scala new file mode 100644 index 00000000..b01d2190 --- /dev/null +++ b/compat/src/main/scala/scala/collection/compat/PackageShared0.scala @@ -0,0 +1,83 @@ +package scala.collection.compat + +import scala.{collection => c} +import scala.collection.{immutable => i, mutable => m} + +private[compat] trait PackageShared0 { + implicit def toCollectionBitSetExtensions(self: c.BitSet): CollectionBitSetExtensions = + new CollectionBitSetExtensions(self) + + implicit def toCollectionSortedMapExtensions[K, V](self: c.SortedMap[K, V]): CollectionSortedMapExtensions[K, V] = + new CollectionSortedMapExtensions[K, V](self) + + implicit def toCollectionSortedSetExtensions[A](self: c.SortedSet[A]): CollectionSortedSetExtensions[A] = + new CollectionSortedSetExtensions[A](self) + + implicit def toImmutableBitSetExtensions(self: i.BitSet): ImmutableBitSetExtensions = + new ImmutableBitSetExtensions(self) + + implicit def toImmutableSortedMapExtensions[K, V](self: i.SortedMap[K, V]): ImmutableSortedMapExtensions[K, V] = + new ImmutableSortedMapExtensions[K, V](self) + + implicit def toImmutableSortedSetExtensions[A](self: i.SortedSet[A]): ImmutableSortedSetExtensions[A] = + new ImmutableSortedSetExtensions[A](self) + + implicit def toImmutableTreeMapExtensions[K, V](self: i.TreeMap[K, V]): ImmutableTreeMapExtensions[K, V] = + new ImmutableTreeMapExtensions[K, V](self) + + implicit def toImmutableTreeSetExtensions[A](self: i.TreeSet[A]): ImmutableTreeSetExtensions[A] = + new ImmutableTreeSetExtensions[A](self) + + implicit def toMutableBitSetExtensions(self: m.BitSet): MutableBitSetExtensions = + new MutableBitSetExtensions(self) + + implicit def toMutableSortedSetExtensions[A](self: m.SortedSet[A]): MutableSortedSetExtensions[A] = + new MutableSortedSetExtensions[A](self) + + implicit def toMutableTreeSetExtensions[A](self: m.TreeSet[A]): MutableTreeSetExtensions[A] = + new MutableTreeSetExtensions[A](self) +} + +class CollectionBitSetExtensions(private val self: c.BitSet) extends AnyVal { + def unsortedSpecific: c.Set[Int] = self +} + +class CollectionSortedMapExtensions[K, V](private val self: c.SortedMap[K, V]) extends AnyVal { + def unsortedSpecific: c.Map[K, V] = self +} + +class CollectionSortedSetExtensions[A](private val self: c.SortedSet[A]) extends AnyVal { + def unsortedSpecific: c.Set[A] = self +} + +class ImmutableBitSetExtensions(private val self: i.BitSet) extends AnyVal { + def unsortedSpecific: i.Set[Int] = self +} + +class ImmutableSortedMapExtensions[K, V](private val self: i.SortedMap[K, V]) extends AnyVal { + def unsortedSpecific: i.Map[K, V] = self +} + +class ImmutableSortedSetExtensions[A](private val self: i.SortedSet[A]) extends AnyVal { + def unsortedSpecific: i.Set[A] = self +} + +class ImmutableTreeMapExtensions[K, V](private val self: i.TreeMap[K, V]) extends AnyVal { + def unsortedSpecific: i.Map[K, V] = self +} + +class ImmutableTreeSetExtensions[A](private val self: i.TreeSet[A]) extends AnyVal { + def unsortedSpecific: i.Set[A] = self +} + +class MutableBitSetExtensions(private val self: m.BitSet) extends AnyVal { + def unsortedSpecific: m.Set[Int] = self +} + +class MutableSortedSetExtensions[A](private val self: m.SortedSet[A]) extends AnyVal { + def unsortedSpecific: m.Set[A] = self +} + +class MutableTreeSetExtensions[A](private val self: m.TreeSet[A]) extends AnyVal { + def unsortedSpecific: m.Set[A] = self +} \ No newline at end of file diff --git a/scalafix/data/src/main/scala-2.12+/fix/Data212Plus.scala b/scalafix/data/src/main/scala-2.12+/fix/Data212Plus.scala new file mode 100644 index 00000000..6199b231 --- /dev/null +++ b/scalafix/data/src/main/scala-2.12+/fix/Data212Plus.scala @@ -0,0 +1,8 @@ +package fix + +import scala.collection.{mutable => m} + +object Data212Plus { + val mSortedMap : m.SortedMap[Int, Int] = ??? + val mTreeMap : m.TreeMap[Int, Int] = ??? +} diff --git a/scalafix/data/src/main/scala/fix/Data.scala b/scalafix/data/src/main/scala/fix/Data.scala new file mode 100644 index 00000000..6d59e796 --- /dev/null +++ b/scalafix/data/src/main/scala/fix/Data.scala @@ -0,0 +1,35 @@ +package fix + +import scala.{collection => c} +import scala.collection.{immutable => i, mutable => m} + +case class NoOrdering(v: Int) + +object Data { + val ordered: Int => Int = x => x + val orderedMap: ((Int, Int)) => ((Int, Int)) = x => x + val ordered2: Int => List[Int] = x => List(x) + val orderedMap2: ((Int, Int)) => List[(Int, Int)] = x => List(x) + + val unordered: Int => NoOrdering = x => NoOrdering(x) + val unorderedMap: ((Int, Int)) => (NoOrdering, Int) = { case (k, v) => (NoOrdering(k), v)} + val unordered2: Int => List[NoOrdering] = x => List(NoOrdering(x)) + val unorderedMap2: ((Int, Int)) => List[(NoOrdering, Int)] = { case (k, v) => List((NoOrdering(k), v))} + + val cSet: c.Set[Int] = c.Set(1) + val cMap: c.Map[Int, Int] = c.Map(1 -> 1) + + val cBitSet : c.BitSet = c.BitSet(1) + val cSortedMap : c.SortedMap[Int, Int] = c.SortedMap(1 -> 1) + val cSortedSet : c.SortedSet[Int] = c.SortedSet(1) + + val iBitSet : i.BitSet = i.BitSet(1) + val iSortedMap : i.SortedMap[Int, Int] = i.SortedMap(1 -> 1) + val iSortedSet : i.SortedSet[Int] = i.SortedSet(1) + val iTreeMap : i.TreeMap[Int, Int] = i.TreeMap(1 -> 1) + val iTreeSet : i.TreeSet[Int] = i.TreeSet(1) + + val mBitSet : m.BitSet = m.BitSet(1) + val mSortedSet : m.SortedSet[Int] = m.SortedSet(1) + val mTreeSet : m.TreeSet[Int] = m.TreeSet(1) +} diff --git a/scalafix/input/src/main/scala/fix/UnsortedSrc.scala b/scalafix/input/src/main/scala/fix/UnsortedSrc.scala new file mode 100644 index 00000000..1f61a1e2 --- /dev/null +++ b/scalafix/input/src/main/scala/fix/UnsortedSrc.scala @@ -0,0 +1,68 @@ +/* +rule = "scala:fix.Experimental" + */ +package fix + +object UnsortedSrc { + import Data._ + + // map + + cSet.map(ordered) + cMap.map(orderedMap) + + cBitSet.map(unordered) + cBitSet.map(ordered) + cSortedMap.map(unorderedMap) + cSortedMap.map(orderedMap) + cSortedSet.map(unordered) + cSortedSet.map(ordered) + + iBitSet.map(unordered) + iBitSet.map(ordered) + iSortedMap.map(unorderedMap) + iSortedMap.map(orderedMap) + iSortedSet.map(unordered) + iSortedSet.map(ordered) + iTreeMap.map(unorderedMap) + iTreeMap.map(orderedMap) + iTreeSet.map(unordered) + iTreeSet.map(ordered) + + mBitSet.map(unordered) + mBitSet.map(ordered) + mSortedSet.map(unordered) + mSortedSet.map(ordered) + mTreeSet.map(unordered) + mTreeSet.map(ordered) + + // flatMap + + cSet.flatMap(ordered2) + cMap.flatMap(orderedMap2) + + cBitSet.flatMap(unordered2) + cBitSet.flatMap(ordered2) + cSortedMap.flatMap(unorderedMap2) + cSortedMap.flatMap(orderedMap2) + cSortedSet.flatMap(unordered2) + cSortedSet.flatMap(ordered2) + + iBitSet.flatMap(unordered2) + iBitSet.flatMap(ordered2) + iSortedMap.flatMap(unorderedMap2) + iSortedMap.flatMap(orderedMap2) + iSortedSet.flatMap(unordered2) + iSortedSet.flatMap(ordered2) + iTreeMap.flatMap(unorderedMap2) + iTreeMap.flatMap(orderedMap2) + iTreeSet.flatMap(unordered2) + iTreeSet.flatMap(ordered2) + + mBitSet.flatMap(unordered2) + mBitSet.flatMap(ordered2) + mSortedSet.flatMap(unordered2) + mSortedSet.flatMap(ordered2) + mTreeSet.flatMap(unordered2) + mTreeSet.flatMap(ordered2) +} diff --git a/scalafix/input/src/main/scala/fix/UnsortedSrc212Plus.scala b/scalafix/input/src/main/scala/fix/UnsortedSrc212Plus.scala new file mode 100644 index 00000000..f7c6148f --- /dev/null +++ b/scalafix/input/src/main/scala/fix/UnsortedSrc212Plus.scala @@ -0,0 +1,15 @@ +/* +rule = "scala:fix.Experimental" + */ +package fix + +object UnsortedSrc212Plus { + import Data._ + import Data212Plus._ + + mSortedMap.map(unorderedMap) + mSortedMap.map(orderedMap) + + mTreeMap.map(unorderedMap) + mTreeMap.map(orderedMap) +} diff --git a/scalafix/output/src/main/scala/fix/UnsortedSrc.scala b/scalafix/output/src/main/scala/fix/UnsortedSrc.scala new file mode 100644 index 00000000..8c84b0bc --- /dev/null +++ b/scalafix/output/src/main/scala/fix/UnsortedSrc.scala @@ -0,0 +1,69 @@ + + + +package fix + +import scala.collection.compat._ +object UnsortedSrc { + import Data._ + + // map + + cSet.map(ordered) + cMap.map(orderedMap) + + cBitSet.unsortedSpecific.map(unordered) + cBitSet.map(ordered) + cSortedMap.unsortedSpecific.map(unorderedMap) + cSortedMap.map(orderedMap) + cSortedSet.unsortedSpecific.map(unordered) + cSortedSet.map(ordered) + + iBitSet.unsortedSpecific.map(unordered) + iBitSet.map(ordered) + iSortedMap.unsortedSpecific.map(unorderedMap) + iSortedMap.map(orderedMap) + iSortedSet.unsortedSpecific.map(unordered) + iSortedSet.map(ordered) + iTreeMap.unsortedSpecific.map(unorderedMap) + iTreeMap.map(orderedMap) + iTreeSet.unsortedSpecific.map(unordered) + iTreeSet.map(ordered) + + mBitSet.unsortedSpecific.map(unordered) + mBitSet.map(ordered) + mSortedSet.unsortedSpecific.map(unordered) + mSortedSet.map(ordered) + mTreeSet.unsortedSpecific.map(unordered) + mTreeSet.map(ordered) + + // flatMap + + cSet.flatMap(ordered2) + cMap.flatMap(orderedMap2) + + cBitSet.unsortedSpecific.flatMap(unordered2) + cBitSet.flatMap(ordered2) + cSortedMap.unsortedSpecific.flatMap(unorderedMap2) + cSortedMap.flatMap(orderedMap2) + cSortedSet.unsortedSpecific.flatMap(unordered2) + cSortedSet.flatMap(ordered2) + + iBitSet.unsortedSpecific.flatMap(unordered2) + iBitSet.flatMap(ordered2) + iSortedMap.unsortedSpecific.flatMap(unorderedMap2) + iSortedMap.flatMap(orderedMap2) + iSortedSet.unsortedSpecific.flatMap(unordered2) + iSortedSet.flatMap(ordered2) + iTreeMap.unsortedSpecific.flatMap(unorderedMap2) + iTreeMap.flatMap(orderedMap2) + iTreeSet.unsortedSpecific.flatMap(unordered2) + iTreeSet.flatMap(ordered2) + + mBitSet.unsortedSpecific.flatMap(unordered2) + mBitSet.flatMap(ordered2) + mSortedSet.unsortedSpecific.flatMap(unordered2) + mSortedSet.flatMap(ordered2) + mTreeSet.unsortedSpecific.flatMap(unordered2) + mTreeSet.flatMap(ordered2) +} diff --git a/scalafix/output212+/src/main/scala/fix/UnsortedSrc212Plus.scala b/scalafix/output212+/src/main/scala/fix/UnsortedSrc212Plus.scala new file mode 100644 index 00000000..c60f0244 --- /dev/null +++ b/scalafix/output212+/src/main/scala/fix/UnsortedSrc212Plus.scala @@ -0,0 +1,16 @@ + + + +package fix + +import scala.collection.compat._ +object UnsortedSrc212Plus { + import Data._ + import Data212Plus._ + + mSortedMap.unsortedSpecific.map(unorderedMap) + mSortedMap.map(orderedMap) + + mTreeMap.unsortedSpecific.map(unorderedMap) + mTreeMap.map(orderedMap) +} diff --git a/scalafix/rules/src/main/scala/fix/Experimental.scala b/scalafix/rules/src/main/scala/fix/Experimental.scala index 19db7b83..35fed124 100644 --- a/scalafix/rules/src/main/scala/fix/Experimental.scala +++ b/scalafix/rules/src/main/scala/fix/Experimental.scala @@ -8,11 +8,11 @@ import scala.meta._ case class Experimental(index: SemanticdbIndex) extends SemanticRule(index, "Experimental") { val CollectionMap = TypeMatcher( - Symbol("_root_.scala.collection.immutable.Map#"), - Symbol("_root_.scala.collection.mutable.Map#"), - Symbol("_root_.scala.Predef.Map#") + "_root_.scala.collection.immutable.Map#", + "_root_.scala.collection.mutable.Map#", + "_root_.scala.Predef.Map#" ) - val CollectionSet = TypeMatcher(Symbol("_root_.scala.collection.Set#")) + val CollectionSet = TypeMatcher("_root_.scala.collection.Set#") // == Symbols == val mapZip = exact( @@ -56,7 +56,111 @@ case class Experimental(index: SemanticdbIndex) extends SemanticRule(index, "Exp }.asPatch } + val unorderingSetOperation = exact( + "_root_.scala.collection.SetLike#map(Lscala/Function1;Lscala/collection/generic/CanBuildFrom;)Ljava/lang/Object;.", + "_root_.scala.collection.TraversableLike#flatMap(Lscala/Function1;Lscala/collection/generic/CanBuildFrom;)Ljava/lang/Object;." + ) + val unorderingMapOperation = exact( + "_root_.scala.collection.TraversableLike#map(Lscala/Function1;Lscala/collection/generic/CanBuildFrom;)Ljava/lang/Object;.", + "_root_.scala.collection.TraversableLike#flatMap(Lscala/Function1;Lscala/collection/generic/CanBuildFrom;)Ljava/lang/Object;." + ) + + val OrderedSetCollection = TypeMatcher( + "_root_.scala.collection.BitSet#", + "_root_.scala.collection.SortedSet#", + "_root_.scala.collection.immutable.BitSet#", + "_root_.scala.collection.immutable.SortedSet#", + "_root_.scala.collection.immutable.TreeSet#", + "_root_.scala.collection.mutable.BitSet#", + "_root_.scala.collection.mutable.SortedSet#", + "_root_.scala.collection.mutable.TreeSet#" + ) + + val OrderedMapCollection = TypeMatcher( + "_root_.scala.collection.SortedMap#", + "_root_.scala.collection.immutable.SortedMap#", + "_root_.scala.collection.immutable.TreeMap#", + "_root_.scala.collection.mutable.SortedMap#", + "_root_.scala.collection.mutable.TreeMap#" + ) + + val mapCanBuildFroms = Set( + "_root_.scala.collection.Map.canBuildFrom()Lscala/collection/generic/CanBuildFrom;.", + "_root_.scala.collection.immutable.Map.canBuildFrom()Lscala/collection/generic/CanBuildFrom;.", + "_root_.scala.collection.mutable.Map.canBuildFrom()Lscala/collection/generic/CanBuildFrom;." + ) + + val setCanBuildFroms = Set( + "_root_.scala.collection.Set.canBuildFrom()Lscala/collection/generic/CanBuildFrom;.", + "_root_.scala.collection.immutable.Set.canBuildFrom()Lscala/collection/generic/CanBuildFrom;.", + "_root_.scala.collection.mutable.Set.canBuildFrom()Lscala/collection/generic/CanBuildFrom;." + ) + + def replaceUnsorted(ctx: RuleCtx): Patch = { + + val synthPos: Map[Int, Synthetic] = ctx.index.synthetics.groupBy(_.position.end).mapValues(_.head).toMap + + def recurse(tree: Tree): Tree = { + tree match { + case Term.Select(_, b) => recurse(b) + case _ => tree + } + } + + def syntheticToSymbol(tree: Tree)(extract: PartialFunction[Tree, Tree]): Option[String] = { + synthPos.get(tree.pos.end).flatMap(synthetic => + synthetic.text.parse[Term].toOption.flatMap{ syntheticTree => + extract.lift(syntheticTree).flatMap{col => + val byPos = synthetic.names.groupBy(s => (s.position.start, s.position.end)).mapValues(_.head).toMap + byPos.get((col.pos.start, col.pos.end)).map(_.symbol.toString) + } + } + ) + } + + val patch = + ctx.tree.collect { + case ap @ Term.Apply(Term.Select(OrderedMapCollection(), unorderingMapOperation(op)), List(f)) => { + val cbf = + syntheticToSymbol(ap){ + case Term.Apply(_, List(Term.ApplyType(sel, _))) => recurse(sel) + } + + if (cbf.map(mapCanBuildFroms.contains).getOrElse(false)) { + ctx.addLeft(op, "unsortedSpecific.") + } else { + Patch.empty + } + } + + case ap @ Term.Apply(Term.Select(OrderedSetCollection(), unorderingSetOperation(op)), List(f)) => { + val cbf = + syntheticToSymbol(ap){ + case Term.Apply(_, List(Term.ApplyType(sel, _))) => recurse(sel) + } + + if (cbf.map(setCanBuildFroms.contains).getOrElse(false)) { + ctx.addLeft(op, "unsortedSpecific.") + } else { + Patch.empty + } + } + + case ap @ Term.Apply(Term.Select(OrderedMapCollection(), op), List(f)) => + println(ctx.index.symbol(op)) + Patch.empty + + }.asPatch + + val compatImport = + if (patch.nonEmpty) ctx.addGlobalImport(importer"scala.collection.compat._") + else Patch.empty + + patch + compatImport + } + override def fix(ctx: RuleCtx): Patch = replaceSetMapPlusMinus(ctx) + - replaceMapZip(ctx) + replaceMapZip(ctx) + + replaceUnsorted(ctx) } diff --git a/scalafix/rules/src/main/scala/fix/TypeMatcher.scala b/scalafix/rules/src/main/scala/fix/TypeMatcher.scala index d3d811b5..7358b667 100644 --- a/scalafix/rules/src/main/scala/fix/TypeMatcher.scala +++ b/scalafix/rules/src/main/scala/fix/TypeMatcher.scala @@ -9,8 +9,8 @@ import scala.meta._ // if we have a simple identifier, we can look at his definition at query it's type // this should be improved in future version of scalameta object TypeMatcher { - def apply(symbols: Symbol*)(implicit index: SemanticdbIndex): TypeMatcher = - new TypeMatcher(symbols: _*)(index) + def apply(symbols: String*)(implicit index: SemanticdbIndex): TypeMatcher = + new TypeMatcher(symbols.map(Symbol(_)): _*)(index) } final class TypeMatcher(symbols: Symbol*)(implicit index: SemanticdbIndex) { From fc7e1e37b4af2462e56e54de179356e4f735f9b6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Guillaume=20Mass=C3=A9?= Date: Thu, 16 Aug 2018 16:40:41 +0200 Subject: [PATCH 3/8] Define a build matrix per file + Add scala 2.13 pre --- .scalafmt.conf | 5 +- CONTRIBUTING.md | 7 +- build.sbt | 126 ++++++++++++------ .../collection/compat/PackageShared.scala | 112 ++++++++++++++-- .../scala/collection/compat/package.scala | 2 +- .../collection/compat/PackageShared0.scala | 83 ------------ project/LatestScala213.scala | 17 ++- project/MultiScalaProject.scala | 10 +- .../main/scala-2.12+/fix/Data212Plus.scala | 4 +- scalafix/data/src/main/scala/fix/Data.scala | 40 +++--- ....scala => CanBuildFromSrc213Failure.scala} | 2 +- ...UnsortedSrc.scala => UnsortedSrcPre.scala} | 0 .../main/scala/fix/BreakoutSrc212Plus.scala | 0 .../fix/CanBuildFromSrc213Failure.scala} | 2 +- .../src/main/scala/fix/CompanionSrc212.scala | 3 - .../src/main/scala/fix/RetainSrc213.scala | 0 .../src/main/scala/fix/RoughlySrc213.scala | 0 .../src/main/scala/fix/SortedSrc212Plus.scala | 0 .../main/scala/fix/TupleNZippedSrc213.scala | 0 .../main/scala/fix/UnsortedSrc212Plus.scala | 7 +- .../src/main/scala/fix/UnsortedSrcPre.scala | 66 +++++++++ .../src/main/scala/fix/UnsortedSrc.scala | 69 ---------- .../src/main/scala/fix/Experimental.scala | 40 +++--- .../src/test/scala/fix/ScalafixTests.scala | 5 +- 24 files changed, 330 insertions(+), 270 deletions(-) delete mode 100644 compat/src/main/scala/scala/collection/compat/PackageShared0.scala rename scalafix/input/src/main/scala/fix/{CanBuildFromNegSrc213Failure.scala => CanBuildFromSrc213Failure.scala} (87%) rename scalafix/input/src/main/scala/fix/{UnsortedSrc.scala => UnsortedSrcPre.scala} (100%) rename scalafix/{output212+ => output-scala-specific}/src/main/scala/fix/BreakoutSrc212Plus.scala (100%) rename scalafix/{output213-failure/src/main/scala/fix/CanBuildFromNegSrc213Failure.scala => output-scala-specific/src/main/scala/fix/CanBuildFromSrc213Failure.scala} (85%) rename scalafix/{output212 => output-scala-specific}/src/main/scala/fix/CompanionSrc212.scala (99%) rename scalafix/{output213 => output-scala-specific}/src/main/scala/fix/RetainSrc213.scala (100%) rename scalafix/{output213 => output-scala-specific}/src/main/scala/fix/RoughlySrc213.scala (100%) rename scalafix/{output212+ => output-scala-specific}/src/main/scala/fix/SortedSrc212Plus.scala (100%) rename scalafix/{output213 => output-scala-specific}/src/main/scala/fix/TupleNZippedSrc213.scala (100%) rename scalafix/{output212+ => output-scala-specific}/src/main/scala/fix/UnsortedSrc212Plus.scala (64%) create mode 100644 scalafix/output-scala-specific/src/main/scala/fix/UnsortedSrcPre.scala delete mode 100644 scalafix/output/src/main/scala/fix/UnsortedSrc.scala diff --git a/.scalafmt.conf b/.scalafmt.conf index 20a6dd5a..4abb2363 100644 --- a/.scalafmt.conf +++ b/.scalafmt.conf @@ -6,10 +6,7 @@ maxColumn = 100 project.excludeFilters = [ "scalafix/input/" "scalafix/output/" - "scalafix/output212/" - "scalafix/output212\\+/" - "scalafix/output213/" - "scalafix/output213-failure/" + "scalafix/output-scala-specific/" ] diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index e21ef57f..9e2e6f83 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -88,12 +88,11 @@ tests are green. You can find more help about the scalafix API in its |data | X | X | X | X | |input | X | | | | |output | | X | X | X | -|output212 | | | X | | -|output212+ | | | X | X | -|output213 | | | | X | -|output213-failure | | | | X | +|specific* | ? | ? | ? | ? | +------------------+-----+-----+-----+-----+ +specific*: see a by source build matrix via the sourceForScalaVersion setting in build.sbt rules: Rule implementations tests: Scalafix testkit launcher (useful to run a single input file) + ``` diff --git a/build.sbt b/build.sbt index 3fe7f7e9..1730ad4b 100644 --- a/build.sbt +++ b/build.sbt @@ -19,6 +19,7 @@ lazy val root = project `scalafix-output211`, `scalafix-output212`, `scalafix-output213`, + `scalafix-output213-pre`, // `scalafix-output213-failure`, `scalafix-rules`, `scalafix-tests` @@ -33,13 +34,16 @@ lazy val scala211 = "2.11.12" lazy val scala212 = "2.12.6" lazy val scalaJs213 = "2.13.0-M4" // Scala.js does no have -pre -lazy val scala213 = "2.13.0-M4" -// lazy val scala213 = "2.13.0-pre-3ae6282" // use the sbt command `latest-213` to fetch the latest version +lazy val scala213 = "2.13.0-M4" +lazy val scala213Pre = LatestScala.getLatestScala213() lazy val scala213Settings = Seq( - resolvers += "scala-pr" at "https://scala-ci.typesafe.com/artifactory/scala-integration/", scalaVersion := scala213 ) +lazy val scala213PreSettings = Seq( + resolvers += "scala-pr" at "https://scala-ci.typesafe.com/artifactory/scala-integration/", + scalaVersion := scala213Pre +) lazy val compat = MultiScalaCrossProject(JSPlatform, JVMPlatform)( "compat", @@ -94,13 +98,21 @@ lazy val compat = MultiScalaCrossProject(JSPlatform, JVMPlatform)( val compat211 = compat(scala211) val compat212 = compat(scala212) val compat213 = compat(scala213, scalaJs213, _.jvmSettings(scala213Settings)) +val compat213Pre = compat( + scala213Pre, + scalaJs213, + _.jvmSettings( + scala213PreSettings + ) +) -lazy val compat211JVM = compat211.jvm -lazy val compat211JS = compat211.js -lazy val compat212JVM = compat212.jvm -lazy val compat212JS = compat212.js -lazy val compat213JVM = compat213.jvm -lazy val compat213JS = compat213.js +lazy val compat211JVM = compat211.jvm +lazy val compat211JS = compat211.js +lazy val compat212JVM = compat212.jvm +lazy val compat212JS = compat212.js +lazy val compat213JVM = compat213.jvm +lazy val compat213JS = compat213.js +lazy val compat213PreJVM = compat213Pre.jvm lazy val `binary-compat-old` = project .in(file("binary-compat/old")) @@ -156,15 +168,19 @@ lazy val sharedScalafixSettings = Seq( ) // common part between input/output -lazy val `scalafix-data` = MultiScalaProject("scalafix-data", - "scalafix/data", - _.settings(sharedScalafixSettings) - .settings(dontPublish)) +lazy val `scalafix-data` = MultiScalaProject( + "scalafix-data", + "scalafix/data", + _.settings(sharedScalafixSettings) + .settings(dontPublish) +) val `scalafix-data211` = `scalafix-data`(scala211, _.dependsOn(compat211JVM)) val `scalafix-data212` = `scalafix-data`(scalafixScala212, _.dependsOn(compat212JVM)) val `scalafix-data213` = `scalafix-data`(scala213, _.settings(scala213Settings).dependsOn(compat213JVM)) +val `scalafix-data213-pre` = + `scalafix-data`(scala213Pre, _.settings(scala213PreSettings).dependsOn(compat213PreJVM)) lazy val `scalafix-input` = project .in(file("scalafix/input")) @@ -176,43 +192,74 @@ lazy val `scalafix-input` = project ) .dependsOn(`scalafix-data212`) -val `scalafix-output` = MultiScalaProject("scalafix-output", - "scalafix/output", - _.settings(sharedScalafixSettings) - .settings(dontPublish) - .disablePlugins(ScalafixPlugin)) +val `scalafix-output` = MultiScalaProject( + "scalafix-output", + "scalafix/output", + _.settings(sharedScalafixSettings) + .settings(dontPublish) + .disablePlugins(ScalafixPlugin) +) + +val sources = Map( // scala211 scala212 scala213 scala213Pre + "BreakoutSrc212Plus" -> List(scala212, scala213, scala213Pre), + "CompanionSrc212" -> List(scala212), + "RetainSrc213" -> List(scala213, scala213Pre), + "RoughlySrc213" -> List(scala213), + "SortedSrc212Plus" -> List(scala212, scala213, scala213Pre), + "TupleNZippedSrc213" -> List(scala213, scala213Pre), + "UnsortedSrc212Plus" -> List(scala212, scala213Pre), + "UnsortedSrcPre" -> List(scala211, scala212, scala213Pre) +) -lazy val addOutput212 = unmanagedSourceDirectories in Compile += output212.value / "scala" -lazy val addOutput212Plus = unmanagedSourceDirectories in Compile += output212Plus.value / "scala" -lazy val addOutput213 = unmanagedSourceDirectories in Compile += output213.value / "scala" -lazy val output212 = Def.setting((baseDirectory in ThisBuild).value / "scalafix/output212/src/main") -lazy val output212Plus = - Def.setting((baseDirectory in ThisBuild).value / "scalafix/output212+/src/main") -lazy val output213 = Def.setting((baseDirectory in ThisBuild).value / "scalafix/output213/src/main") +val reverseSources: Map[String, List[String]] = + sources.toList + .flatMap { + case (k, vs) => + vs.map(v => (v, k)) + } + .groupBy(_._1) + .mapValues(_.map(_._2)) + .toMap + .withDefaultValue(Nil) + +val scalaSpecific = + Def.setting((baseDirectory in ThisBuild).value / "scalafix/output-scala-specific/src/main/") + +lazy val sourceForScalaVersion = Seq( + sbt.Keys.sources in Compile ++= { + val fileNames = reverseSources(scalaVersion.value) + fileNames.map(fileName => scalaSpecific.value / "scala/fix" / (fileName + ".scala")) + } +) lazy val `scalafix-output211` = `scalafix-output`( scala211, - _.dependsOn(`scalafix-data211`) + _.settings(sourceForScalaVersion) + .dependsOn(`scalafix-data211`) ) lazy val `scalafix-output212` = `scalafix-output`( scala212, - _.settings(addOutput212) - .settings(addOutput212Plus) + _.settings(sourceForScalaVersion) .dependsOn(`scalafix-data212`) ) lazy val `scalafix-output213` = `scalafix-output`( scala213, - _.settings(addOutput213) - .settings(addOutput212Plus) + _.settings(sourceForScalaVersion) .settings(scala213Settings) .dependsOn(`scalafix-data213`) ) +lazy val `scalafix-output213-pre` = `scalafix-output`( + scala213Pre, + _.settings(sourceForScalaVersion) + .settings(scala213PreSettings) + .dependsOn(`scalafix-data213-pre`) +) + lazy val `scalafix-output213-failure` = project .in(file("scalafix/output213-failure")) - .settings(sharedScalafixSettings) .settings(scala213Settings) .settings(dontPublish) @@ -225,22 +272,17 @@ lazy val `scalafix-tests` = project libraryDependencies += "ch.epfl.scala" % "scalafix-testkit" % scalafixVersion % Test cross CrossVersion.full, buildInfoPackage := "build", buildInfoKeys := Seq[BuildInfoKey]( - "inputSourceroot" -> sourceDirectory.in(`scalafix-input`, Compile).value, - "outputSourceroot" -> (baseDirectory in ThisBuild).value / "scalafix/output/src/main", - "output212Sourceroot" -> output212.value, - "output212PlusSourceroot" -> output212Plus.value, - "output213Sourceroot" -> output213.value, - "output212PlusSourceroot" -> output212Plus.value, - "output213FailureSourceroot" -> sourceDirectory - .in(`scalafix-output213-failure`, Compile) - .value, + "inputSourceroot" -> sourceDirectory.in(`scalafix-input`, Compile).value, + "outputSourceroot" -> (baseDirectory in ThisBuild).value / "scalafix/output/src/main", + "outputScalaSpecific" -> scalaSpecific.value, "inputClassdirectory" -> classDirectory.in(`scalafix-input`, Compile).value ), test in Test := (test in Test) .dependsOn( compile in (`scalafix-output211`, Compile), compile in (`scalafix-output212`, Compile), - compile in (`scalafix-output213`, Compile) + compile in (`scalafix-output213`, Compile), + compile in (`scalafix-output213-pre`, Compile) ) .value ) @@ -285,7 +327,7 @@ inThisBuild(releaseCredentials) // required by sbt-scala-module inThisBuild( Seq( - crossScalaVersions := Seq(scala211, scala212, scala213), + crossScalaVersions := Seq(scala211, scala212, scala213, scala213Pre), commands += Command.command("latest-213") { state => LatestScala.printLatestScala213() state diff --git a/compat/src/main/scala-2.11_2.12/scala/collection/compat/PackageShared.scala b/compat/src/main/scala-2.11_2.12/scala/collection/compat/PackageShared.scala index 896da9c2..596fb539 100644 --- a/compat/src/main/scala-2.11_2.12/scala/collection/compat/PackageShared.scala +++ b/compat/src/main/scala-2.11_2.12/scala/collection/compat/PackageShared.scala @@ -7,7 +7,7 @@ import scala.collection.{immutable => i, mutable => m} import scala.{collection => c} /** The collection compatibility API */ -private[compat] trait PackageShared extends PackageShared0 { +private[compat] trait PackageShared { import CompatImpl._ /** @@ -97,31 +97,40 @@ private[compat] trait PackageShared extends PackageShared0 { builder.result() } - implicit def toImmutableSortedMapCompanionExtensions(fact: i.SortedMap.type): ImmutableSortedMapCompanionExtensions = + implicit def toImmutableSortedMapCompanionExtensions( + fact: i.SortedMap.type): ImmutableSortedMapCompanionExtensions = new ImmutableSortedMapCompanionExtensions(fact) - implicit def toImmutableListMapCompanionExtensions(fact: i.ListMap.type): ImmutableListMapCompanionExtensions = + implicit def toImmutableListMapCompanionExtensions( + fact: i.ListMap.type): ImmutableListMapCompanionExtensions = new ImmutableListMapCompanionExtensions(fact) - implicit def toImmutableHashMapCompanionExtensions(fact: i.HashMap.type): ImmutableHashMapCompanionExtensions = + implicit def toImmutableHashMapCompanionExtensions( + fact: i.HashMap.type): ImmutableHashMapCompanionExtensions = new ImmutableHashMapCompanionExtensions(fact) - implicit def toImmutableTreeMapCompanionExtensions(fact: i.TreeMap.type): ImmutableTreeMapCompanionExtensions = + implicit def toImmutableTreeMapCompanionExtensions( + fact: i.TreeMap.type): ImmutableTreeMapCompanionExtensions = new ImmutableTreeMapCompanionExtensions(fact) - implicit def toImmutableIntMapCompanionExtensions(fact: i.IntMap.type): ImmutableIntMapCompanionExtensions = + implicit def toImmutableIntMapCompanionExtensions( + fact: i.IntMap.type): ImmutableIntMapCompanionExtensions = new ImmutableIntMapCompanionExtensions(fact) - implicit def toImmutableLongMapCompanionExtensions(fact: i.LongMap.type): ImmutableLongMapCompanionExtensions = + implicit def toImmutableLongMapCompanionExtensions( + fact: i.LongMap.type): ImmutableLongMapCompanionExtensions = new ImmutableLongMapCompanionExtensions(fact) - implicit def toMutableLongMapCompanionExtensions(fact: m.LongMap.type): MutableLongMapCompanionExtensions = + implicit def toMutableLongMapCompanionExtensions( + fact: m.LongMap.type): MutableLongMapCompanionExtensions = new MutableLongMapCompanionExtensions(fact) - implicit def toMutableHashMapCompanionExtensions(fact: m.HashMap.type): MutableHashMapCompanionExtensions = + implicit def toMutableHashMapCompanionExtensions( + fact: m.HashMap.type): MutableHashMapCompanionExtensions = new MutableHashMapCompanionExtensions(fact) - implicit def toMutableListMapCompanionExtensions(fact: m.ListMap.type): MutableListMapCompanionExtensions = + implicit def toMutableListMapCompanionExtensions( + fact: m.ListMap.type): MutableListMapCompanionExtensions = new MutableListMapCompanionExtensions(fact) implicit def toMutableMapCompanionExtensions(fact: m.Map.type): MutableMapCompanionExtensions = @@ -145,6 +154,45 @@ private[compat] trait PackageShared extends PackageShared0 { self: TraversableOnce[A]): TraversableOnceExtensionMethods[A] = new TraversableOnceExtensionMethods[A](self) + implicit def toCollectionBitSetExtensions(self: c.BitSet): CollectionBitSetExtensions = + new CollectionBitSetExtensions(self) + + implicit def toCollectionSortedMapExtensions[K, V]( + self: c.SortedMap[K, V]): CollectionSortedMapExtensions[K, V] = + new CollectionSortedMapExtensions[K, V](self) + + implicit def toCollectionSortedSetExtensions[A]( + self: c.SortedSet[A]): CollectionSortedSetExtensions[A] = + new CollectionSortedSetExtensions[A](self) + + implicit def toImmutableBitSetExtensions(self: i.BitSet): ImmutableBitSetExtensions = + new ImmutableBitSetExtensions(self) + + implicit def toImmutableSortedMapExtensions[K, V]( + self: i.SortedMap[K, V]): ImmutableSortedMapExtensions[K, V] = + new ImmutableSortedMapExtensions[K, V](self) + + implicit def toImmutableSortedSetExtensions[A]( + self: i.SortedSet[A]): ImmutableSortedSetExtensions[A] = + new ImmutableSortedSetExtensions[A](self) + + implicit def toImmutableTreeMapExtensions[K, V]( + self: i.TreeMap[K, V]): ImmutableTreeMapExtensions[K, V] = + new ImmutableTreeMapExtensions[K, V](self) + + implicit def toImmutableTreeSetExtensions[A](self: i.TreeSet[A]): ImmutableTreeSetExtensions[A] = + new ImmutableTreeSetExtensions[A](self) + + implicit def toMutableBitSetExtensions(self: m.BitSet): MutableBitSetExtensions = + new MutableBitSetExtensions(self) + + implicit def toMutableSortedSetExtensions[A]( + self: m.SortedSet[A]): MutableSortedSetExtensions[A] = + new MutableSortedSetExtensions[A](self) + + implicit def toMutableTreeSetExtensions[A](self: m.TreeSet[A]): MutableTreeSetExtensions[A] = + new MutableTreeSetExtensions[A](self) + // This really belongs into scala.collection but there's already a package object // in scala-library so we can't add to it type IterableOnce[+X] = c.TraversableOnce[X] @@ -225,3 +273,47 @@ class TraversableOnceExtensionMethods[A](private val self: c.TraversableOnce[A]) class TraversableExtensionMethods[A](private val self: c.Traversable[A]) extends AnyVal { def iterableFactory: GenericCompanion[Traversable] = self.companion } + +class CollectionBitSetExtensions(private val self: c.BitSet) extends AnyVal { + def unsorted: c.Set[Int] = self +} + +class CollectionSortedMapExtensions[K, V](private val self: c.SortedMap[K, V]) extends AnyVal { + def unsorted: c.Map[K, V] = self +} + +class CollectionSortedSetExtensions[A](private val self: c.SortedSet[A]) extends AnyVal { + def unsorted: c.Set[A] = self +} + +class ImmutableBitSetExtensions(private val self: i.BitSet) extends AnyVal { + def unsorted: i.Set[Int] = self +} + +class ImmutableSortedMapExtensions[K, V](private val self: i.SortedMap[K, V]) extends AnyVal { + def unsorted: i.Map[K, V] = self +} + +class ImmutableSortedSetExtensions[A](private val self: i.SortedSet[A]) extends AnyVal { + def unsorted: i.Set[A] = self +} + +class ImmutableTreeMapExtensions[K, V](private val self: i.TreeMap[K, V]) extends AnyVal { + def unsorted: i.Map[K, V] = self +} + +class ImmutableTreeSetExtensions[A](private val self: i.TreeSet[A]) extends AnyVal { + def unsorted: i.Set[A] = self +} + +class MutableBitSetExtensions(private val self: m.BitSet) extends AnyVal { + def unsorted: m.Set[Int] = self +} + +class MutableSortedSetExtensions[A](private val self: m.SortedSet[A]) extends AnyVal { + def unsorted: m.Set[A] = self +} + +class MutableTreeSetExtensions[A](private val self: m.TreeSet[A]) extends AnyVal { + def unsorted: m.Set[A] = self +} diff --git a/compat/src/main/scala-2.13/scala/collection/compat/package.scala b/compat/src/main/scala-2.13/scala/collection/compat/package.scala index 5e68c66d..c324fc37 100644 --- a/compat/src/main/scala-2.13/scala/collection/compat/package.scala +++ b/compat/src/main/scala-2.13/scala/collection/compat/package.scala @@ -1,6 +1,6 @@ package scala.collection -package object compat extends PackageShared0 { +package object compat { type Factory[-A, +C] = scala.collection.Factory[A, C] val Factory = scala.collection.Factory diff --git a/compat/src/main/scala/scala/collection/compat/PackageShared0.scala b/compat/src/main/scala/scala/collection/compat/PackageShared0.scala deleted file mode 100644 index b01d2190..00000000 --- a/compat/src/main/scala/scala/collection/compat/PackageShared0.scala +++ /dev/null @@ -1,83 +0,0 @@ -package scala.collection.compat - -import scala.{collection => c} -import scala.collection.{immutable => i, mutable => m} - -private[compat] trait PackageShared0 { - implicit def toCollectionBitSetExtensions(self: c.BitSet): CollectionBitSetExtensions = - new CollectionBitSetExtensions(self) - - implicit def toCollectionSortedMapExtensions[K, V](self: c.SortedMap[K, V]): CollectionSortedMapExtensions[K, V] = - new CollectionSortedMapExtensions[K, V](self) - - implicit def toCollectionSortedSetExtensions[A](self: c.SortedSet[A]): CollectionSortedSetExtensions[A] = - new CollectionSortedSetExtensions[A](self) - - implicit def toImmutableBitSetExtensions(self: i.BitSet): ImmutableBitSetExtensions = - new ImmutableBitSetExtensions(self) - - implicit def toImmutableSortedMapExtensions[K, V](self: i.SortedMap[K, V]): ImmutableSortedMapExtensions[K, V] = - new ImmutableSortedMapExtensions[K, V](self) - - implicit def toImmutableSortedSetExtensions[A](self: i.SortedSet[A]): ImmutableSortedSetExtensions[A] = - new ImmutableSortedSetExtensions[A](self) - - implicit def toImmutableTreeMapExtensions[K, V](self: i.TreeMap[K, V]): ImmutableTreeMapExtensions[K, V] = - new ImmutableTreeMapExtensions[K, V](self) - - implicit def toImmutableTreeSetExtensions[A](self: i.TreeSet[A]): ImmutableTreeSetExtensions[A] = - new ImmutableTreeSetExtensions[A](self) - - implicit def toMutableBitSetExtensions(self: m.BitSet): MutableBitSetExtensions = - new MutableBitSetExtensions(self) - - implicit def toMutableSortedSetExtensions[A](self: m.SortedSet[A]): MutableSortedSetExtensions[A] = - new MutableSortedSetExtensions[A](self) - - implicit def toMutableTreeSetExtensions[A](self: m.TreeSet[A]): MutableTreeSetExtensions[A] = - new MutableTreeSetExtensions[A](self) -} - -class CollectionBitSetExtensions(private val self: c.BitSet) extends AnyVal { - def unsortedSpecific: c.Set[Int] = self -} - -class CollectionSortedMapExtensions[K, V](private val self: c.SortedMap[K, V]) extends AnyVal { - def unsortedSpecific: c.Map[K, V] = self -} - -class CollectionSortedSetExtensions[A](private val self: c.SortedSet[A]) extends AnyVal { - def unsortedSpecific: c.Set[A] = self -} - -class ImmutableBitSetExtensions(private val self: i.BitSet) extends AnyVal { - def unsortedSpecific: i.Set[Int] = self -} - -class ImmutableSortedMapExtensions[K, V](private val self: i.SortedMap[K, V]) extends AnyVal { - def unsortedSpecific: i.Map[K, V] = self -} - -class ImmutableSortedSetExtensions[A](private val self: i.SortedSet[A]) extends AnyVal { - def unsortedSpecific: i.Set[A] = self -} - -class ImmutableTreeMapExtensions[K, V](private val self: i.TreeMap[K, V]) extends AnyVal { - def unsortedSpecific: i.Map[K, V] = self -} - -class ImmutableTreeSetExtensions[A](private val self: i.TreeSet[A]) extends AnyVal { - def unsortedSpecific: i.Set[A] = self -} - -class MutableBitSetExtensions(private val self: m.BitSet) extends AnyVal { - def unsortedSpecific: m.Set[Int] = self -} - -class MutableSortedSetExtensions[A](private val self: m.SortedSet[A]) extends AnyVal { - def unsortedSpecific: m.Set[A] = self -} - -class MutableTreeSetExtensions[A](private val self: m.TreeSet[A]) extends AnyVal { - def unsortedSpecific: m.Set[A] = self -} \ No newline at end of file diff --git a/project/LatestScala213.scala b/project/LatestScala213.scala index 79727898..f07e563a 100644 --- a/project/LatestScala213.scala +++ b/project/LatestScala213.scala @@ -10,7 +10,18 @@ import java.net.URL // NB. maven-metadata.xml does not point to the latest version object LatestScala { + def getLatestScala213(): String = getLatestScala213WithDate()._1 + def printLatestScala213(): Unit = { + val (latestVersion, lastestDate) = getLatestScala213WithDate() + println() + println(latestVersion) + println() + println(lastestDate) + println() + } + + private def getLatestScala213WithDate(): (String, String) = { val url = "https://scala-ci.typesafe.com/artifactory/scala-integration/org/scala-lang/scala-library/" val index = new URL(url).openStream() @@ -35,10 +46,6 @@ object LatestScala { val latestVersion = version val lastestDate = dateFormat.print(date) - println() - println(latestVersion) - println() - println(lastestDate) - println() + (latestVersion, lastestDate) } } diff --git a/project/MultiScalaProject.scala b/project/MultiScalaProject.scala index ccccd7f6..431a9a51 100644 --- a/project/MultiScalaProject.scala +++ b/project/MultiScalaProject.scala @@ -32,7 +32,15 @@ trait MultiScala { major + minor } - def projectIdPerScala(name: String, scalaV: String): String = s"$name${majorMinor(scalaV)}" + def projectIdPerScala(name: String, scalaV: String): String = { + val preSuffix = + if (scalaV.startsWith("2.13.0-pre")) "-pre" + else "" + + val scalaVersionSuffix = majorMinor(scalaV) + preSuffix + + s"${name}${scalaVersionSuffix}" + } def srcFull(base: String): Seq[Def.Setting[_]] = { Seq( diff --git a/scalafix/data/src/main/scala-2.12+/fix/Data212Plus.scala b/scalafix/data/src/main/scala-2.12+/fix/Data212Plus.scala index 6199b231..a792f0ef 100644 --- a/scalafix/data/src/main/scala-2.12+/fix/Data212Plus.scala +++ b/scalafix/data/src/main/scala-2.12+/fix/Data212Plus.scala @@ -3,6 +3,6 @@ package fix import scala.collection.{mutable => m} object Data212Plus { - val mSortedMap : m.SortedMap[Int, Int] = ??? - val mTreeMap : m.TreeMap[Int, Int] = ??? + val mSortedMap: m.SortedMap[Int, Int] = ??? + val mTreeMap: m.TreeMap[Int, Int] = ??? } diff --git a/scalafix/data/src/main/scala/fix/Data.scala b/scalafix/data/src/main/scala/fix/Data.scala index 6d59e796..a6452b10 100644 --- a/scalafix/data/src/main/scala/fix/Data.scala +++ b/scalafix/data/src/main/scala/fix/Data.scala @@ -6,30 +6,32 @@ import scala.collection.{immutable => i, mutable => m} case class NoOrdering(v: Int) object Data { - val ordered: Int => Int = x => x - val orderedMap: ((Int, Int)) => ((Int, Int)) = x => x - val ordered2: Int => List[Int] = x => List(x) + val ordered: Int => Int = x => x + val orderedMap: ((Int, Int)) => ((Int, Int)) = x => x + val ordered2: Int => List[Int] = x => List(x) val orderedMap2: ((Int, Int)) => List[(Int, Int)] = x => List(x) - val unordered: Int => NoOrdering = x => NoOrdering(x) - val unorderedMap: ((Int, Int)) => (NoOrdering, Int) = { case (k, v) => (NoOrdering(k), v)} - val unordered2: Int => List[NoOrdering] = x => List(NoOrdering(x)) - val unorderedMap2: ((Int, Int)) => List[(NoOrdering, Int)] = { case (k, v) => List((NoOrdering(k), v))} + val unordered: Int => NoOrdering = x => NoOrdering(x) + val unorderedMap: ((Int, Int)) => (NoOrdering, Int) = { case (k, v) => (NoOrdering(k), v) } + val unordered2: Int => List[NoOrdering] = x => List(NoOrdering(x)) + val unorderedMap2: ((Int, Int)) => List[(NoOrdering, Int)] = { + case (k, v) => List((NoOrdering(k), v)) + } - val cSet: c.Set[Int] = c.Set(1) + val cSet: c.Set[Int] = c.Set(1) val cMap: c.Map[Int, Int] = c.Map(1 -> 1) - val cBitSet : c.BitSet = c.BitSet(1) - val cSortedMap : c.SortedMap[Int, Int] = c.SortedMap(1 -> 1) - val cSortedSet : c.SortedSet[Int] = c.SortedSet(1) + val cBitSet: c.BitSet = c.BitSet(1) + val cSortedMap: c.SortedMap[Int, Int] = c.SortedMap(1 -> 1) + val cSortedSet: c.SortedSet[Int] = c.SortedSet(1) - val iBitSet : i.BitSet = i.BitSet(1) - val iSortedMap : i.SortedMap[Int, Int] = i.SortedMap(1 -> 1) - val iSortedSet : i.SortedSet[Int] = i.SortedSet(1) - val iTreeMap : i.TreeMap[Int, Int] = i.TreeMap(1 -> 1) - val iTreeSet : i.TreeSet[Int] = i.TreeSet(1) + val iBitSet: i.BitSet = i.BitSet(1) + val iSortedMap: i.SortedMap[Int, Int] = i.SortedMap(1 -> 1) + val iSortedSet: i.SortedSet[Int] = i.SortedSet(1) + val iTreeMap: i.TreeMap[Int, Int] = i.TreeMap(1 -> 1) + val iTreeSet: i.TreeSet[Int] = i.TreeSet(1) - val mBitSet : m.BitSet = m.BitSet(1) - val mSortedSet : m.SortedSet[Int] = m.SortedSet(1) - val mTreeSet : m.TreeSet[Int] = m.TreeSet(1) + val mBitSet: m.BitSet = m.BitSet(1) + val mSortedSet: m.SortedSet[Int] = m.SortedSet(1) + val mTreeSet: m.TreeSet[Int] = m.TreeSet(1) } diff --git a/scalafix/input/src/main/scala/fix/CanBuildFromNegSrc213Failure.scala b/scalafix/input/src/main/scala/fix/CanBuildFromSrc213Failure.scala similarity index 87% rename from scalafix/input/src/main/scala/fix/CanBuildFromNegSrc213Failure.scala rename to scalafix/input/src/main/scala/fix/CanBuildFromSrc213Failure.scala index 7a8e08fb..b083a2a3 100644 --- a/scalafix/input/src/main/scala/fix/CanBuildFromNegSrc213Failure.scala +++ b/scalafix/input/src/main/scala/fix/CanBuildFromSrc213Failure.scala @@ -7,7 +7,7 @@ import scala.language.higherKinds import collection.generic.CanBuildFrom -object CanBuildFromNegSrc213Failure { +object CanBuildFromSrc213Failure { // negative test def g[C0, A, C1[_]](c0: C0)(implicit cbf3: CanBuildFrom[C0, A, C1[A]]): C1[A] = { diff --git a/scalafix/input/src/main/scala/fix/UnsortedSrc.scala b/scalafix/input/src/main/scala/fix/UnsortedSrcPre.scala similarity index 100% rename from scalafix/input/src/main/scala/fix/UnsortedSrc.scala rename to scalafix/input/src/main/scala/fix/UnsortedSrcPre.scala diff --git a/scalafix/output212+/src/main/scala/fix/BreakoutSrc212Plus.scala b/scalafix/output-scala-specific/src/main/scala/fix/BreakoutSrc212Plus.scala similarity index 100% rename from scalafix/output212+/src/main/scala/fix/BreakoutSrc212Plus.scala rename to scalafix/output-scala-specific/src/main/scala/fix/BreakoutSrc212Plus.scala diff --git a/scalafix/output213-failure/src/main/scala/fix/CanBuildFromNegSrc213Failure.scala b/scalafix/output-scala-specific/src/main/scala/fix/CanBuildFromSrc213Failure.scala similarity index 85% rename from scalafix/output213-failure/src/main/scala/fix/CanBuildFromNegSrc213Failure.scala rename to scalafix/output-scala-specific/src/main/scala/fix/CanBuildFromSrc213Failure.scala index c3d02aaa..457d83bb 100644 --- a/scalafix/output213-failure/src/main/scala/fix/CanBuildFromNegSrc213Failure.scala +++ b/scalafix/output-scala-specific/src/main/scala/fix/CanBuildFromSrc213Failure.scala @@ -7,7 +7,7 @@ import scala.language.higherKinds import collection.generic.CanBuildFrom -object CanBuildFromNegSrc213Failure { +object CanBuildFromSrc213Failure { // negative test def g[C0, A, C1[_]](c0: C0)(implicit cbf3: CanBuildFrom[C0, A, C1[A]]): C1[A] = { diff --git a/scalafix/output212/src/main/scala/fix/CompanionSrc212.scala b/scalafix/output-scala-specific/src/main/scala/fix/CompanionSrc212.scala similarity index 99% rename from scalafix/output212/src/main/scala/fix/CompanionSrc212.scala rename to scalafix/output-scala-specific/src/main/scala/fix/CompanionSrc212.scala index 4bae8dd0..f8c74455 100644 --- a/scalafix/output212/src/main/scala/fix/CompanionSrc212.scala +++ b/scalafix/output-scala-specific/src/main/scala/fix/CompanionSrc212.scala @@ -1,6 +1,3 @@ - - - package fix import scala.collection.{immutable => i, mutable => m} diff --git a/scalafix/output213/src/main/scala/fix/RetainSrc213.scala b/scalafix/output-scala-specific/src/main/scala/fix/RetainSrc213.scala similarity index 100% rename from scalafix/output213/src/main/scala/fix/RetainSrc213.scala rename to scalafix/output-scala-specific/src/main/scala/fix/RetainSrc213.scala diff --git a/scalafix/output213/src/main/scala/fix/RoughlySrc213.scala b/scalafix/output-scala-specific/src/main/scala/fix/RoughlySrc213.scala similarity index 100% rename from scalafix/output213/src/main/scala/fix/RoughlySrc213.scala rename to scalafix/output-scala-specific/src/main/scala/fix/RoughlySrc213.scala diff --git a/scalafix/output212+/src/main/scala/fix/SortedSrc212Plus.scala b/scalafix/output-scala-specific/src/main/scala/fix/SortedSrc212Plus.scala similarity index 100% rename from scalafix/output212+/src/main/scala/fix/SortedSrc212Plus.scala rename to scalafix/output-scala-specific/src/main/scala/fix/SortedSrc212Plus.scala diff --git a/scalafix/output213/src/main/scala/fix/TupleNZippedSrc213.scala b/scalafix/output-scala-specific/src/main/scala/fix/TupleNZippedSrc213.scala similarity index 100% rename from scalafix/output213/src/main/scala/fix/TupleNZippedSrc213.scala rename to scalafix/output-scala-specific/src/main/scala/fix/TupleNZippedSrc213.scala diff --git a/scalafix/output212+/src/main/scala/fix/UnsortedSrc212Plus.scala b/scalafix/output-scala-specific/src/main/scala/fix/UnsortedSrc212Plus.scala similarity index 64% rename from scalafix/output212+/src/main/scala/fix/UnsortedSrc212Plus.scala rename to scalafix/output-scala-specific/src/main/scala/fix/UnsortedSrc212Plus.scala index c60f0244..3767d601 100644 --- a/scalafix/output212+/src/main/scala/fix/UnsortedSrc212Plus.scala +++ b/scalafix/output-scala-specific/src/main/scala/fix/UnsortedSrc212Plus.scala @@ -1,6 +1,3 @@ - - - package fix import scala.collection.compat._ @@ -8,9 +5,9 @@ object UnsortedSrc212Plus { import Data._ import Data212Plus._ - mSortedMap.unsortedSpecific.map(unorderedMap) + mSortedMap.unsorted.map(unorderedMap) mSortedMap.map(orderedMap) - mTreeMap.unsortedSpecific.map(unorderedMap) + mTreeMap.unsorted.map(unorderedMap) mTreeMap.map(orderedMap) } diff --git a/scalafix/output-scala-specific/src/main/scala/fix/UnsortedSrcPre.scala b/scalafix/output-scala-specific/src/main/scala/fix/UnsortedSrcPre.scala new file mode 100644 index 00000000..e40f7250 --- /dev/null +++ b/scalafix/output-scala-specific/src/main/scala/fix/UnsortedSrcPre.scala @@ -0,0 +1,66 @@ +package fix + +import scala.collection.compat._ +object UnsortedSrc { + import Data._ + + // map + + cSet.map(ordered) + cMap.map(orderedMap) + + cBitSet.unsorted.map(unordered) + cBitSet.map(ordered) + cSortedMap.unsorted.map(unorderedMap) + cSortedMap.map(orderedMap) + cSortedSet.unsorted.map(unordered) + cSortedSet.map(ordered) + + iBitSet.unsorted.map(unordered) + iBitSet.map(ordered) + iSortedMap.unsorted.map(unorderedMap) + iSortedMap.map(orderedMap) + iSortedSet.unsorted.map(unordered) + iSortedSet.map(ordered) + iTreeMap.unsorted.map(unorderedMap) + iTreeMap.map(orderedMap) + iTreeSet.unsorted.map(unordered) + iTreeSet.map(ordered) + + mBitSet.unsorted.map(unordered) + mBitSet.map(ordered) + mSortedSet.unsorted.map(unordered) + mSortedSet.map(ordered) + mTreeSet.unsorted.map(unordered) + mTreeSet.map(ordered) + + // flatMap + + cSet.flatMap(ordered2) + cMap.flatMap(orderedMap2) + + cBitSet.unsorted.flatMap(unordered2) + cBitSet.flatMap(ordered2) + cSortedMap.unsorted.flatMap(unorderedMap2) + cSortedMap.flatMap(orderedMap2) + cSortedSet.unsorted.flatMap(unordered2) + cSortedSet.flatMap(ordered2) + + iBitSet.unsorted.flatMap(unordered2) + iBitSet.flatMap(ordered2) + iSortedMap.unsorted.flatMap(unorderedMap2) + iSortedMap.flatMap(orderedMap2) + iSortedSet.unsorted.flatMap(unordered2) + iSortedSet.flatMap(ordered2) + iTreeMap.unsorted.flatMap(unorderedMap2) + iTreeMap.flatMap(orderedMap2) + iTreeSet.unsorted.flatMap(unordered2) + iTreeSet.flatMap(ordered2) + + mBitSet.unsorted.flatMap(unordered2) + mBitSet.flatMap(ordered2) + mSortedSet.unsorted.flatMap(unordered2) + mSortedSet.flatMap(ordered2) + mTreeSet.unsorted.flatMap(unordered2) + mTreeSet.flatMap(ordered2) +} diff --git a/scalafix/output/src/main/scala/fix/UnsortedSrc.scala b/scalafix/output/src/main/scala/fix/UnsortedSrc.scala deleted file mode 100644 index 8c84b0bc..00000000 --- a/scalafix/output/src/main/scala/fix/UnsortedSrc.scala +++ /dev/null @@ -1,69 +0,0 @@ - - - -package fix - -import scala.collection.compat._ -object UnsortedSrc { - import Data._ - - // map - - cSet.map(ordered) - cMap.map(orderedMap) - - cBitSet.unsortedSpecific.map(unordered) - cBitSet.map(ordered) - cSortedMap.unsortedSpecific.map(unorderedMap) - cSortedMap.map(orderedMap) - cSortedSet.unsortedSpecific.map(unordered) - cSortedSet.map(ordered) - - iBitSet.unsortedSpecific.map(unordered) - iBitSet.map(ordered) - iSortedMap.unsortedSpecific.map(unorderedMap) - iSortedMap.map(orderedMap) - iSortedSet.unsortedSpecific.map(unordered) - iSortedSet.map(ordered) - iTreeMap.unsortedSpecific.map(unorderedMap) - iTreeMap.map(orderedMap) - iTreeSet.unsortedSpecific.map(unordered) - iTreeSet.map(ordered) - - mBitSet.unsortedSpecific.map(unordered) - mBitSet.map(ordered) - mSortedSet.unsortedSpecific.map(unordered) - mSortedSet.map(ordered) - mTreeSet.unsortedSpecific.map(unordered) - mTreeSet.map(ordered) - - // flatMap - - cSet.flatMap(ordered2) - cMap.flatMap(orderedMap2) - - cBitSet.unsortedSpecific.flatMap(unordered2) - cBitSet.flatMap(ordered2) - cSortedMap.unsortedSpecific.flatMap(unorderedMap2) - cSortedMap.flatMap(orderedMap2) - cSortedSet.unsortedSpecific.flatMap(unordered2) - cSortedSet.flatMap(ordered2) - - iBitSet.unsortedSpecific.flatMap(unordered2) - iBitSet.flatMap(ordered2) - iSortedMap.unsortedSpecific.flatMap(unorderedMap2) - iSortedMap.flatMap(orderedMap2) - iSortedSet.unsortedSpecific.flatMap(unordered2) - iSortedSet.flatMap(ordered2) - iTreeMap.unsortedSpecific.flatMap(unorderedMap2) - iTreeMap.flatMap(orderedMap2) - iTreeSet.unsortedSpecific.flatMap(unordered2) - iTreeSet.flatMap(ordered2) - - mBitSet.unsortedSpecific.flatMap(unordered2) - mBitSet.flatMap(ordered2) - mSortedSet.unsortedSpecific.flatMap(unordered2) - mSortedSet.flatMap(ordered2) - mTreeSet.unsortedSpecific.flatMap(unordered2) - mTreeSet.flatMap(ordered2) -} diff --git a/scalafix/rules/src/main/scala/fix/Experimental.scala b/scalafix/rules/src/main/scala/fix/Experimental.scala index 35fed124..e1a34759 100644 --- a/scalafix/rules/src/main/scala/fix/Experimental.scala +++ b/scalafix/rules/src/main/scala/fix/Experimental.scala @@ -98,49 +98,57 @@ case class Experimental(index: SemanticdbIndex) extends SemanticRule(index, "Exp def replaceUnsorted(ctx: RuleCtx): Patch = { - val synthPos: Map[Int, Synthetic] = ctx.index.synthetics.groupBy(_.position.end).mapValues(_.head).toMap + val synthPos: Map[Int, Synthetic] = + ctx.index.synthetics.groupBy(_.position.end).mapValues(_.head).toMap def recurse(tree: Tree): Tree = { tree match { case Term.Select(_, b) => recurse(b) - case _ => tree + case _ => tree } } def syntheticToSymbol(tree: Tree)(extract: PartialFunction[Tree, Tree]): Option[String] = { - synthPos.get(tree.pos.end).flatMap(synthetic => - synthetic.text.parse[Term].toOption.flatMap{ syntheticTree => - extract.lift(syntheticTree).flatMap{col => - val byPos = synthetic.names.groupBy(s => (s.position.start, s.position.end)).mapValues(_.head).toMap - byPos.get((col.pos.start, col.pos.end)).map(_.symbol.toString) - } - } - ) + synthPos + .get(tree.pos.end) + .flatMap(synthetic => + synthetic.text.parse[Term].toOption.flatMap { syntheticTree => + extract.lift(syntheticTree).flatMap { col => + val byPos = + synthetic.names + .groupBy(s => (s.position.start, s.position.end)) + .mapValues(_.head) + .toMap + byPos.get((col.pos.start, col.pos.end)).map(_.symbol.toString) + } + }) } val patch = ctx.tree.collect { - case ap @ Term.Apply(Term.Select(OrderedMapCollection(), unorderingMapOperation(op)), List(f)) => { + case ap @ Term.Apply(Term.Select(OrderedMapCollection(), unorderingMapOperation(op)), + List(f)) => { val cbf = - syntheticToSymbol(ap){ + syntheticToSymbol(ap) { case Term.Apply(_, List(Term.ApplyType(sel, _))) => recurse(sel) } if (cbf.map(mapCanBuildFroms.contains).getOrElse(false)) { - ctx.addLeft(op, "unsortedSpecific.") + ctx.addLeft(op, "unsorted.") } else { Patch.empty } } - case ap @ Term.Apply(Term.Select(OrderedSetCollection(), unorderingSetOperation(op)), List(f)) => { + case ap @ Term.Apply(Term.Select(OrderedSetCollection(), unorderingSetOperation(op)), + List(f)) => { val cbf = - syntheticToSymbol(ap){ + syntheticToSymbol(ap) { case Term.Apply(_, List(Term.ApplyType(sel, _))) => recurse(sel) } if (cbf.map(setCanBuildFroms.contains).getOrElse(false)) { - ctx.addLeft(op, "unsortedSpecific.") + ctx.addLeft(op, "unsorted.") } else { Patch.empty } diff --git a/scalafix/tests/src/test/scala/fix/ScalafixTests.scala b/scalafix/tests/src/test/scala/fix/ScalafixTests.scala index 7602e556..a9ccd6d6 100644 --- a/scalafix/tests/src/test/scala/fix/ScalafixTests.scala +++ b/scalafix/tests/src/test/scala/fix/ScalafixTests.scala @@ -10,10 +10,7 @@ class ScalafixTests AbsolutePath(build.BuildInfo.inputSourceroot), Seq( AbsolutePath(build.BuildInfo.outputSourceroot), - AbsolutePath(build.BuildInfo.output212Sourceroot), - AbsolutePath(build.BuildInfo.output213Sourceroot), - AbsolutePath(build.BuildInfo.output212PlusSourceroot), - AbsolutePath(build.BuildInfo.output213FailureSourceroot) + AbsolutePath(build.BuildInfo.outputScalaSpecific) ) ) { From 65d96a792e5c454f918084897cdc179715411424 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Guillaume=20Mass=C3=A9?= Date: Thu, 16 Aug 2018 17:14:05 +0200 Subject: [PATCH 4/8] Add 2.13.0-pre to the build matrix --- .travis.yml | 9 ++++++++- project/Version.scala | 18 +++++++++++++----- 2 files changed, 21 insertions(+), 6 deletions(-) diff --git a/.travis.yml b/.travis.yml index 3a279b11..9f5346e0 100644 --- a/.travis.yml +++ b/.travis.yml @@ -11,6 +11,7 @@ scala: - 2.11.12 - 2.12.6 - 2.13.0-M4 + - 2.13.0-pre jdk: - openjdk6 - oraclejdk8 @@ -40,6 +41,9 @@ matrix: - jdk: openjdk6 scala: 2.13.0-M4 + - jdk: openjdk6 + scala: 2.13.0-pre + # ? - jdk: oraclejdk8 scala: 2.11.12 @@ -47,6 +51,9 @@ matrix: # 2.13.0-M4 is not available in Scala.js 1.0.0-M3 - scala: 2.13.0-M4 env: SCALAJS_VERSION=1.0.0-M3 + + - scala: 2.13.0-pre + env: SCALAJS_VERSION=1.0.0-M3 include: # run migration test @@ -73,7 +80,7 @@ matrix: # | oraclejdk8 | 2.12.6 | js | 0.6.23 | | # | oraclejdk8 | 2.12.6 | js | 1.0.0-M3 | | # | oraclejdk8 | 2.13.0-M4 | jvm | | | -# | oraclejdk8 | 2.13.0-M4 | js | 0.6.23 | | +# | oraclejdk8 | 2.13.0-pre| jvm | | | # | oraclejdk8 | 2.12.6 | jvm | | true | before_script: ./checkCLA.sh diff --git a/project/Version.scala b/project/Version.scala index f934172d..38352ec2 100644 --- a/project/Version.scala +++ b/project/Version.scala @@ -1,20 +1,28 @@ -case class Version(major: Int, minor: Int, patch: Int) { - def binary: String = s"${major}${minor}" +case class Version(major: Int, minor: Int, patch: Int, isPre: Boolean = false) { + def binary: String = { + val suffix = if (isPre) "-pre" else "" + s"${major}${minor}${suffix}" + } override def toString: String = s"${major}.${minor}.${patch}" } object Version { private val versionRegex0 = "v?([0-9]+)\\.([0-9]+)\\.([0-9]+)".r private val versionRegex1 = "v?([0-9]+)\\.([0-9]+)\\.([0-9]+)-M([0-9]+)".r - private val versionRegex2 = "([0-9]+)\\.([0-9]+)".r + private val versionRegex2 = "v?([0-9]+)\\.([0-9]+)\\.([0-9]+)-pre".r + private val versionRegex3 = "([0-9]+)\\.([0-9]+)".r def parse(raw: String): Option[Version] = { raw match { case versionRegex0(major, minor, patch) => Some(Version(major.toInt, minor.toInt, patch.toInt)) case versionRegex1(major, minor, patch, _) => Some(Version(major.toInt, minor.toInt, patch.toInt)) - case versionRegex2(major, minor) => Some(Version(major.toInt, minor.toInt, 0)) - case _ => None + case versionRegex2(major, minor, patch) => + Some(Version(major.toInt, minor.toInt, patch.toInt, isPre = true)) + case versionRegex3(major, minor) => + Some(Version(major.toInt, minor.toInt, 0)) + case _ => + None } } } From 0dc87037f273116d4c82df00c083b9d789f01706 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Guillaume=20Mass=C3=A9?= Date: Thu, 16 Aug 2018 17:17:50 +0200 Subject: [PATCH 5/8] Remove Scala 2.13.0-pre + Scala.js from the build matrix --- .travis.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.travis.yml b/.travis.yml index 9f5346e0..f67138be 100644 --- a/.travis.yml +++ b/.travis.yml @@ -54,6 +54,9 @@ matrix: - scala: 2.13.0-pre env: SCALAJS_VERSION=1.0.0-M3 + + - scala: 2.13.0-pre + env: SCALAJS_VERSION=0.6.23 include: # run migration test From 06f763bc4ff637983f694714980b12e0230e01eb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Guillaume=20Mass=C3=A9?= Date: Thu, 16 Aug 2018 22:10:21 +0200 Subject: [PATCH 6/8] Fix Scala.js ci entry --- build.sbt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build.sbt b/build.sbt index 1730ad4b..e75b8f1e 100644 --- a/build.sbt +++ b/build.sbt @@ -299,7 +299,7 @@ lazy val dontPublish = Seq( val preRelease = "pre-release" val travisScalaVersion = sys.env.get("TRAVIS_SCALA_VERSION").flatMap(Version.parse) val releaseVersion = sys.env.get("TRAVIS_TAG").flatMap(Version.parse) -val isScalaJs = sys.env.get("SCALAJS_VERSION").nonEmpty +val isScalaJs = sys.env.get("SCALAJS_VERSION").map(_.nonEmpty).getOrElse(false) val isScalafix = sys.env.get("TEST_SCALAFIX").nonEmpty val isScalafmt = sys.env.get("TEST_SCALAFMT").nonEmpty val isBinaryCompat = sys.env.get("TEST_BINARY_COMPAT").nonEmpty From 5c914c2e61a29dede64563e93db20893a9a909bb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Guillaume=20Mass=C3=A9?= Date: Mon, 20 Aug 2018 10:15:36 +0200 Subject: [PATCH 7/8] Keep formatting for source <-> scala version map --- build.sbt | 20 +++++++++++--------- 1 file changed, 11 insertions(+), 9 deletions(-) diff --git a/build.sbt b/build.sbt index e75b8f1e..66558d6a 100644 --- a/build.sbt +++ b/build.sbt @@ -200,16 +200,18 @@ val `scalafix-output` = MultiScalaProject( .disablePlugins(ScalafixPlugin) ) -val sources = Map( // scala211 scala212 scala213 scala213Pre - "BreakoutSrc212Plus" -> List(scala212, scala213, scala213Pre), - "CompanionSrc212" -> List(scala212), - "RetainSrc213" -> List(scala213, scala213Pre), - "RoughlySrc213" -> List(scala213), - "SortedSrc212Plus" -> List(scala212, scala213, scala213Pre), - "TupleNZippedSrc213" -> List(scala213, scala213Pre), - "UnsortedSrc212Plus" -> List(scala212, scala213Pre), - "UnsortedSrcPre" -> List(scala211, scala212, scala213Pre) +// format: off +val sources = Map( // scala211 scala212 scala213 scala213Pre + "BreakoutSrc212Plus" -> List( scala212, scala213, scala213Pre), + "CompanionSrc212" -> List( scala212 ), + "RetainSrc213" -> List( scala213, scala213Pre), + "RoughlySrc213" -> List( scala213 ), + "SortedSrc212Plus" -> List( scala212, scala213, scala213Pre), + "TupleNZippedSrc213" -> List( scala213, scala213Pre), + "UnsortedSrc212Plus" -> List( scala212, scala213Pre), + "UnsortedSrcPre" -> List(scala211, scala212, scala213Pre) ) +// format: on val reverseSources: Map[String, List[String]] = sources.toList From 4a2ca09f029f15188262c967cc95f7f708fe825e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Guillaume=20Mass=C3=A9?= Date: Mon, 20 Aug 2018 11:46:58 +0200 Subject: [PATCH 8/8] Only fetch 2.13.X in typesafe artifactory --- project/LatestScala213.scala | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/project/LatestScala213.scala b/project/LatestScala213.scala index f07e563a..4bd6c0c5 100644 --- a/project/LatestScala213.scala +++ b/project/LatestScala213.scala @@ -33,12 +33,14 @@ object LatestScala { val versionsAndDateRaw = pre.split("\n").drop(1).dropRight(1) val dateFormat = DateTimeFormat.forPattern("dd-MMM-yyyy HH:mm") val versionsAndDate = - versionsAndDateRaw.map { line => - val Array(version, dateRaw) = line.split("/") - val dateClean = dateRaw.dropRight(1).trim - val date = DateTime.parse(dateClean, dateFormat) - (version, date) - } + versionsAndDateRaw + .map { line => + val Array(version, dateRaw) = line.split("/") + val dateClean = dateRaw.dropRight(1).trim + val date = DateTime.parse(dateClean, dateFormat) + (version, date) + } + .filter { case (version, _) => version.startsWith("2.13.0") } def Descending[T: Ordering] = implicitly[Ordering[T]].reverse