WIP

core/src/main/scala/scalafix/rewrite/Rewrite.scala

@@ -17,7 +17,7 @@ object Rewrite {
   }
 
   val syntaxRewrites: Seq[Rewrite] = Seq(ProcedureSyntax, VolatileLazyVal)
-  val semanticRewrites: Seq[Rewrite] = Seq(ExplicitImplicit)
+  val semanticRewrites: Seq[Rewrite] = Seq(ExplicitImplicit, Xor2Either)
   val allRewrites: Seq[Rewrite] = syntaxRewrites ++ semanticRewrites
   val name2rewrite: Map[String, Rewrite] =
     allRewrites.map(x => x.toString -> x).toMap

core/src/main/scala/scalafix/rewrite/SemanticApi.scala

@@ -1,7 +1,9 @@
 package scalafix.rewrite
 
 import scala.meta.Defn
+import scala.meta.Tree
 import scala.meta.Type
+import scala.meta.parsers.Parse
 
 /** A custom semantic api for scalafix rewrites.
   *
@@ -18,4 +20,6 @@ trait SemanticApi {
 
   /** Returns the type annotation for given val/def. */
   def typeSignature(defn: Defn): Option[Type]
+
+  def desugared[A <: Tree](tree: A)(implicit parse: Parse[A]): Option[A]
 }

core/src/main/scala/scalafix/rewrite/Xor2Either.scala

@@ -0,0 +1,24 @@
+package scalafix.rewrite
+
+import scala.{meta => m}
+import scalafix.util.Patch
+import scalafix.util.Whitespace
+import scalafix.util.logger
+
+case object Xor2Either extends Rewrite {
+  override def rewrite(ast: m.Tree, ctx: RewriteCtx): Seq[Patch] = {
+    import scala.meta._
+    val semantic = getSemanticApi(ctx)
+    ast.collect {
+      case t: m.Type.Ref
+          if semantic
+            .desugared(t: m.Type)(m.parsers.Parse.parseType)
+            .exists(_.syntax.contains("Xor")) =>
+        logger.elem(t.syntax, semantic.desugared(t: Type))
+        val tok = t.tokens.head
+        Seq(
+          Patch(tok, tok, tok.syntax + "BANANA")
+        )
+    }.flatten
+  }
+}

core/src/test/resources/Xor/basic.source

@@ -0,0 +1,10 @@
+rewrites = [Xor2Either]
+<<< ONLY xor 1
+import cats.data.Xor
+trait A {
+  val r: Xor[Int, String]
+}
+>>>
+trait A {
+  val r: Either[Int, String]
+}

scalafix-nsc/src/main/scala/scalafix/nsc/NscSemanticApi.scala

@@ -2,7 +2,9 @@ package scalafix.nsc
 
 import scala.collection.mutable
 import scala.meta.Dialect
+import scala.meta.Tree
 import scala.meta.Type
+import scala.meta.parsers.Parse
 import scala.reflect.internal.util.SourceFile
 import scala.{meta => m}
 import scalafix.Fixed
@@ -97,6 +99,18 @@ trait NscSemanticApi extends ReflectToolkit {
     builder
   }
 
+  private def collect[T](gtree: g.Tree)(
+      pf: PartialFunction[g.Tree, T]): Seq[T] = {
+    val builder = Seq.newBuilder[T]
+    val f = pf.lift
+    def iter(gtree: g.Tree): Unit = {
+      f(gtree).foreach(builder += _)
+      gtree.children.foreach(iter)
+    }
+    iter(gtree)
+    builder.result()
+  }
+
   private def getSemanticApi(unit: g.CompilationUnit,
                              config: ScalafixConfig): SemanticApi = {
     val offsets = offsetToType(unit.body, config.dialect)
@@ -111,6 +125,24 @@ trait NscSemanticApi extends ReflectToolkit {
             None
         }
       }
+
+      override def desugared[T <: Tree](tree: T)(
+          implicit parse: Parse[T]): Option[T] = {
+        logger.elem(tree, unit.body)
+        val result = collect[Option[T]](unit.body) {
+          case t
+              if t.pos.isDefined &&
+                t.pos.start == tree.pos.start.offset =>
+            import scala.meta._
+            parse(m.Input.String(t.toString()), config.dialect) match {
+              case Parsed.Success(x) => Some(x)
+              case _ => None
+            }
+          case t if { logger.elem(t.toString(), g.showRaw(t)); false } => None
+        }.flatten
+        logger.elem(result)
+        result.headOption
+      }
     }
   }
 

scalafix-nsc/src/test/scala/cats/data/Xor.scala

@@ -0,0 +1,8 @@
+package cats.data
+
+sealed abstract class Xor[+A, +B] extends Product with Serializable
+
+object Xor {
+  final case class Left[+A](a: A) extends (A Xor Nothing)
+  final case class Right[+B](b: B) extends (Nothing Xor B)
+}