Upgrade to latest scalameta pre-release. (#157)

* Upgrade to latest scalameta pre-release.

It seems scalameta/scalameta#847 broke a few
rewrites. However, I still prefer the new behavior since I belive
synthetic .apply and should belong to aliases and that the rewrites that
broke with this change were only conincidentally working.
Once scalameta/scalameta#846 is fixed then we
should be able to go back to the old behavior, if we so chose.

* Clean up scripted tests.

- only one project: cross-build
- test syntactic and semantic rewrites
- use buildDirectory as sourcepath

Author: olafurpg

project/Dependencies.scala

@@ -2,7 +2,7 @@ import sbt._
 /* scalafmt: { maxColumn = 120 }*/
 
 object Dependencies {
-  val scalametaV = "1.8.0-604-2128ff7b"
+  val scalametaV = "1.8.0-650-890aeec1"
   val paradiseV = "3.0.0-308-ec15a2f8"
   val metaconfigV = "0.3.2"
   var testClasspath: String = "empty"

scalafix-cli/src/main/scala/scalafix/cli/Cli.scala

@@ -194,28 +194,13 @@ case class ScalafixOptions(
       case (Some(cp), Some(sp)) =>
         val tryMirror = for {
           mirror <- Try {
-            // TODO(olafur) offline.Mirror needs to document what can go wrong in the types.
-            // see https://github.com/scalameta/scalameta/issues/814
-            val files =
-              sp.split(File.pathSeparator)
-                .flatMap(FileOps.listFiles)
-                .filter { x =>
-                  // need to filter here because of https://github.com/scalameta/scalameta/issues/814
-                  new File(x).parse[Source] match {
-                    case parsers.Parsed.Success(_) => true
-                    case _ => false
-                  }
-                }
-            if (files.isEmpty) throw Cli.EmptySourcepath // need to fix offline.Mirror :v
-            val mirror =
-              Mirror(cp, files.mkString(File.pathSeparator))
+            val mirror = Mirror(Classpath(cp), Sourcepath(sp))
             mirror.sources // ugh. need to trigger lazy to validate that all files parse
             mirror
           }
         } yield Option(mirror)
         tryMirror match {
           case Success(x) => Ok(x)
-          case scala.util.Failure(Cli.EmptySourcepath) => Ok(None)
           case scala.util.Failure(e) => ConfError.msg(e.toString).notOk
         }
       case (None, None) =>
@@ -252,7 +237,6 @@ object Cli {
   val default = ScalafixOptions()
   // Run this at the end of the world, calls sys.exit.
 
-  case object EmptySourcepath extends Exception(s"No sources parse")
   case class NonZeroExitCode(n: Int)
       extends Exception(s"Expected exit code 0. Got exit code $n")
   def main(args: Array[String]): Unit = {

scalafix-core/src/main/scala/scalafix/patch/OrganizeImports.scala

@@ -9,6 +9,7 @@ import scalafix.patch.TreePatch.AddGlobalImport
 import scalafix.patch.TreePatch.RemoveGlobalImport
 import scalafix.rewrite.RewriteCtx
 import scalafix.syntax._
+import scalafix.syntax.XtensionRefSymbolOpt
 import scalafix.util.CanonicalImport
 
 private[this] class OrganizeImports[T] private (implicit ctx: RewriteCtx,
@@ -25,7 +26,7 @@ private[this] class OrganizeImports[T] private (implicit ctx: RewriteCtx,
 
   def fullyQualifiedName(ref: Ref): Option[Ref] =
     for {
-      sym <- mirror.symbol(ref).toOption
+      sym <- ref.symbolOpt
       name <- sym.to[Ref].toOption
       strippedRoot = name.transform {
         case q"_root_.$nme" => nme

scalafix-core/src/main/scala/scalafix/patch/Replacer.scala

@@ -10,16 +10,12 @@ import scalafix.rewrite.RewriteCtx
 import scalafix.patch.TreePatch.AddGlobalImport
 import scalafix.patch.TreePatch.Rename
 
+import org.scalameta.logger
+
 private[this] class Replacer(implicit ctx: RewriteCtx, mirror: Mirror) {
   object `:withSymbol:` {
     def unapply(ref: Ref): Option[(Ref, Symbol)] =
-      Try(
-        mirror.symbol(ref) match {
-          case semantic.Completed.Success(symbol) =>
-            Some(ref -> symbol.normalized)
-          case _ => None
-        }
-      ).toOption.flatten
+      ref.symbolOpt.map(sym => ref -> sym.normalized)
   }
 
   def toTokenPatches(ast: Tree, replacements: Seq[Replace]): Seq[Patch] = {
@@ -29,17 +25,17 @@ private[this] class Replacer(implicit ctx: RewriteCtx, mirror: Mirror) {
       override def apply(tree: Tree): Unit = {
         tree match {
           case (ref: Ref) `:withSymbol:` symbol =>
-            builder ++=
-              replacements
-                .find { x =>
-                  x.from == symbol
-                }
-                .toList
-                .flatMap(
-                  replace =>
-                    ctx.addLeft(ref.tokens.head, replace.to.syntax) +:
-                      (ref.tokens.map(TokenPatch.Remove.apply) ++
-                      replace.additionalImports.map(x => AddGlobalImport(x))))
+            val patches = replacements
+              .find { x =>
+                x.from == symbol
+              }
+              .toList
+              .flatMap { replace =>
+                ctx.addLeft(ref.tokens.head, replace.to.syntax) +:
+                  (ref.tokens.map(TokenPatch.Remove.apply) ++
+                  replace.additionalImports.map(x => AddGlobalImport(x)))
+              }
+            builder ++= patches
           case imp: Import => // Do nothing
           case _ => super.apply(tree)
         }
@@ -84,8 +80,7 @@ object Renamer {
         if (renameSymbols.isEmpty) None
         else
           for {
-            // TODO(olafur) avoid Try() once don't require `Mirror` in Replacer.
-            symbol <- mirror.symbol(arg).toOption
+            symbol <- arg.symbolOpt
             rename <- renameSymbols.find(_.matches(symbol))
             tok <- arg.tokens.headOption
           } yield tok -> rename.to

scalafix-core/src/main/scala/scalafix/rewrite/NoAutoTupling.scala

@@ -21,9 +21,7 @@ case class NoAutoTupling(mirror: Mirror) extends SemanticRewrite(mirror) {
     val fixed = MutableSet.empty[Seq[Term.Arg]]
     ctx.tree.collect {
       case q"${fun: Term.Ref}(...$argss)" if argss.nonEmpty =>
-        mirror
-          .symbol(fun)
-          .toOption
+        fun.symbolOpt
           .collect {
             case Symbol.Global(_, Signature.Method(_, jvmSignature)) =>
               val argListSignatures =

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

@@ -10,9 +10,7 @@ case class Xor2Either(mirror: Mirror) extends SemanticRewrite(mirror) {
   override def rewrite(ctx: RewriteCtx): Patch = {
     val importImplicits = ctx.tree.collectFirst {
       case t: Term.Name
-          if mirror
-            .symbol(t)
-            .toOption
+          if t.symbolOpt
             .exists(_.normalized == Symbol("_root_.cats.data.Xor.map.")) =>
         ctx.addGlobalImport(importer"cats.implicits._")
     }

scalafix-core/src/main/scala/scalafix/syntax/package.scala

@@ -4,7 +4,6 @@ import scala.collection.IterableLike
 import scala.collection.generic.CanBuildFrom
 import scala.collection.mutable
 import scala.meta._
-import scala.meta.semantic.Completed
 import scala.meta.semantic.Signature
 import scala.meta.semantic.Symbol
 import scala.meta.tokens.Token
@@ -60,6 +59,10 @@ package object syntax {
     }
   }
 
+  implicit class XtensionRefSymbolOpt(ref: Ref)(implicit mirror: Mirror) {
+    def symbolOpt: Option[Symbol] = Try(ref.symbol).toOption
+  }
+
   implicit class XtensionTermRef(ref: Term.Ref) {
     def toTypeRef: Type.Ref = ref match {
       case Term.Name(name) => Type.Name(name)
@@ -80,18 +83,6 @@ package object syntax {
     }
   }
 
-  implicit class XtensionCompleted[T](completed: Completed[T]) {
-    // TODO(olafur) contribute these upstream
-    def toOption: Option[T] = completed match {
-      case Completed.Success(e) => Some(e)
-      case _ => None
-    }
-    def toEither: Either[Exception, T] = completed match {
-      case Completed.Success(e) => Right(e)
-      case Completed.Error(e) => Left(e)
-    }
-    def toTry: Try[T] = Try(completed.get)
-  }
   implicit class XtensionSymbol(symbol: Symbol) {
 
     /** Returns simplified version of this Symbol.

scalafix-sbt/src/main/scala/scalafix/sbt/ScalafixPlugin.scala

@@ -57,7 +57,7 @@ object ScalafixPlugin extends AutoPlugin {
         .map(x => "--config" :: x.getAbsolutePath :: Nil)
         .getOrElse(Nil)
     val log = streams.value.log
-    val sourcepath = scalahostSourcepath.value.flatten
+    val sourcepath = List(baseDirectory.in(ThisBuild).value)
     val classpath = scalahostClasspath.value.flatMap(_.map(_.data))
     def format(files: Seq[File]): String =
       files.map(_.getAbsolutePath).mkString(File.pathSeparator)

scalafix-sbt/src/sbt-test/sbt-scalafix/basic/.scalafix.conf

@@ -0,0 +1,4 @@
+rewrites = [
+  ProcedureSyntax
+  NoAutoTupling
+]

scalafix-sbt/src/sbt-test/sbt-scalafix/basic/build.sbt

@@ -0,0 +1,49 @@
+lazy val root = project
+  .in(file("."))
+  .aggregate(
+    scala211,
+    scala210,
+    scala212
+  )
+
+lazy val scala210 = project.settings(scalaVersion := "2.10.5")
+lazy val scala211 = project.settings(scalaVersion := "2.11.11")
+lazy val scala212 = project.settings(scalaVersion := "2.12.2")
+
+TaskKey[Unit]("check") := {
+  val assertContentMatches: ((String, String) => Boolean) =
+    ScalafixTestUtility.assertContentMatches(streams.value) _
+  val expected =
+    """object Main {
+      |  def foo(a: (Int, String)) = a
+      |  foo((1, "str"))
+      |  def main(args: Array[String]): Unit = {
+      |    println(1)
+      |  }
+      |}""".stripMargin
+  val testExpected = expected.replaceFirst("Main", "MainTest")
+  def unchanged(code: String) =
+    code
+      .replace(": Unit =", "")
+      .replace("((", "(")
+      .replace("\"))", "\")")
+
+  val results: Seq[Boolean] =
+    Seq(scala210, scala211, scala212).flatMap { project =>
+      val prefix = project.id
+      Seq(
+        assertContentMatches(
+          prefix + "/src/test/scala/MainTest.scala",
+          if (prefix.contains("210")) unchanged(testExpected)
+          else testExpected
+        ),
+        assertContentMatches(
+          prefix + "/src/main/scala/Main.scala",
+          if (prefix.contains("210")) unchanged(expected)
+          else expected
+        )
+      )
+    }
+
+  if (results.contains(false)) sys.error("Assertions failed.")
+}

scalafix-sbt/src/sbt-test/sbt-scalafix/basic/p1/src/main/scala/Test.scala

@@ -0,0 +1,7 @@
+object Main {
+  def foo(a: (Int, String)) = a
+  foo(1, "str")
+  def main(args: Array[String]) {
+    println(1)
+  }
+}