Add NoExtendsApp rewrite (#188)

* Add NoExtendsApp rewrite

* Assume indentation of two spaces

This seems pretty much universal in Scala projects.

* Make removeTokensBetween private

* Use Symbol instead of String in removeParentFromTemplate

* Use shorter syntax for rewrites configuration

* Run scalafmt

* Handle single-line blocks as body

* Add explicit return type to main method

* Remove redundant info from the docs.

* Warn in case of empty or missing body.

Author: gabro

readme/Rewrites.scalatex

@@ -197,5 +197,26 @@
     @p
       The two syntaxes are equivalent and the presence of the @code{val} keyword has been deprecated since Scala 2.10.
 
+  @sect(NoExtendsApp.toString)
+    @p
+      Replaces usage of the @code{scala.App} trait with an explicit main function.
+
+    @hl.scala
+      // before
+      object Main extends App {
+        println(s"Hello ${args(0)}")
+      }
+
+      // after
+      object Main {
+        def main(args: Array[String]) = {
+          println(s"Hello ${args(0)}")
+        }
+      }
+
+    @p
+      The @code{scala.App} trait uses @code{DelayedInit}, which has been dropped in Dotty.
+      More info @lnk("here", "https://github.com/lampepfl/dotty/blob/master/docs/docs/reference/dropped/delayed-init.md").
+
   @sect{Planned rewrites...}
     See @lnk("here", "https://github.com/scalacenter/scalafix/labels/rewrite").

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

@@ -0,0 +1,120 @@
+package scalafix
+package rewrite
+
+import scala.meta._
+import scalafix.syntax._
+import scalafix.util.{Whitespace => _, _}
+import scala.meta.contrib._
+import scala.meta.tokens.Token._
+
+//TODO(gabro): move the helpers somewhere else
+import NoExtendsAppSyntax._
+
+case class NoExtendsApp(mirror: Mirror) extends SemanticRewrite(mirror) {
+  override def rewrite(ctx: RewriteCtx): Patch = {
+    def wrapBodyInMain(template: Template) =
+      ctx
+        .templateBodyTokens(template) match {
+        case None =>
+          ctx.reporter.warn(
+            "Missing or empty body for object that extends scala.App. See http://dotty.epfl.ch/docs/reference/dropped/delayed-init.html for possible workarounds.",
+            template.pos
+          )
+          Patch.empty
+        case Some(body) =>
+          val open =
+            ctx.addLeft(body.head,
+                        s"\n  def main(args: Array[String]): Unit = {")
+          val indentBody = ctx.indent(body)
+          // this handles bodies on a single line like:
+          //   object Main extends App { println(args(0)) }
+          val closingSpaces = if (indentBody.isDefined) " " * 2 else ""
+          val close = ctx.addRight(body.last, s"$closingSpaces}\n")
+          open + indentBody.asPatch + close
+      }
+
+    ctx.tree.collect {
+      case t: Defn.Object =>
+        ctx.removeParentFromTemplate(Symbol("_root_.scala.App."), t.templ) +
+          wrapBodyInMain(t.templ)
+    }.asPatch
+  }
+}
+
+object NoExtendsAppSyntax {
+  implicit class XtensionRewriteCtx(ctx: RewriteCtx) {
+
+    def templateBodyTokens(template: Template): Option[Tokens] = {
+      val tokens = template.tokens
+      val maybeTokens = for {
+        close <- tokens.lastOption
+        if close.is[RightBrace]
+        open <- ctx.matching.open(close.asInstanceOf[RightBrace])
+      } yield
+        tokens
+          .dropWhile(_.pos.start.offset <= open.pos.start.offset)
+          .dropRight(1)
+      maybeTokens.filterNot(_.isEmpty)
+    }
+
+    def indent(tokens: Tokens, numberOfSpaces: Int = 2): Option[Patch] =
+      tokens.dropRightWhile(t => !t.is[Newline]).lastOption.map {
+        lastNewLine =>
+          tokens.collect {
+            case nl @ Newline() if nl != lastNewLine =>
+              ctx.addRight(nl, " " * numberOfSpaces)
+          }.asPatch
+      }
+
+    private[scalafix] def removeTokensBetween(
+        from: Token,
+        to: Token,
+        removeLeadingWhitespace: Boolean = true): Patch = {
+      val toRemove = ctx.tokenList
+        .slice(
+          ctx.tokenList.prev(from),
+          ctx.tokenList
+            .next(to) // apply next twice to include the trailing space
+        )
+      val leadingToRemove =
+        if (removeLeadingWhitespace)
+          ctx.tokenList.leading(from).takeWhile(_.is[Whitespace])
+        else
+          Nil
+
+      (toRemove ++ leadingToRemove)
+        .map(ctx.removeToken)
+        .asPatch
+    }
+
+    def removeParentFromTemplate(normalized: Symbol, template: Template)(
+        implicit m: Mirror): Patch = {
+      val maybePatch = for {
+        treeToRemove <- template.parents
+          .collect { case c: Ctor.Ref => c }
+          .find(_.symbolOpt.map(_.normalized) == Some(normalized))
+        nameToRemove <- treeToRemove.tokens.headOption
+        leadingExtendsOrWithToken <- ctx.tokenList
+          .leading(nameToRemove)
+          .find(t => t.is[KwExtends] || t.is[KwWith])
+      } yield
+        (template.parents.length, leadingExtendsOrWithToken) match {
+          // 1) object Foo extends ToRemove { ... }
+          // or
+          // 2) object Foo extends Something with ToRemove { ... }
+          case (1, _) | (_, KwWith()) =>
+            ctx.removeTokensBetween(leadingExtendsOrWithToken, nameToRemove)
+
+          // 3) object Foo extends ToRemove with Something
+          case (_, KwExtends()) =>
+            (for {
+              trailingWith <- ctx.tokenList
+                .trailing(nameToRemove)
+                .find(t => t.is[KwWith])
+            } yield
+              ctx.removeTokensBetween(nameToRemove, trailingWith)).asPatch
+        }
+      maybePatch.asPatch
+    }
+  }
+}

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

@@ -15,7 +15,8 @@ object ScalafixRewrites {
     ExplicitReturnTypes(mirror),
     RemoveUnusedImports(mirror),
     Xor2Either(mirror),
-    NoAutoTupling(mirror)
+    NoAutoTupling(mirror),
+    NoExtendsApp(mirror)
   )
   def all(mirror: Mirror): List[Rewrite] =
     syntax ++ semantic(mirror)

scalafix-tests/input/src/main/scala/test/NoExtendsApp.scala

@@ -0,0 +1,48 @@
+/*
+rewrites = NoExtendsApp
+*/
+package test
+
+object Main extends App {
+  println(s"Hello, ${args(0)}")
+  println(s"Hello 2, ${args(0)}")
+}
+
+trait Something
+object Main2 extends Something with App{
+  println(s"Hello, ${args(0)}")
+  println(s"Hello 2, ${args(0)}")
+}
+
+object Main3 extends App with Something{
+  println(s"Hello, ${args(0)}")
+  println(s"Hello 2, ${args(0)}")
+}
+
+object Main4 extends App with Something
+
+object Main5 extends App with Something {}
+
+object Main6
+  extends App
+  with Something
+
+object Main7
+  extends Something
+  with App
+
+object Main8
+  extends Something with
+  App
+
+object Main9 extends
+  App with
+  Something
+
+import scala.{ App => Ppa }
+object Main10 extends Ppa with Something {
+  println(s"Hello, ${args(0)}")
+  println(s"Hello 2, ${args(0)}")
+}
+
+object Main11 extends App { println(args(0)) }

scalafix-tests/output/src/main/scala/test/NoExtendsApp.scala

@@ -0,0 +1,51 @@
+package test
+
+object Main {
+  def main(args: Array[String]): Unit = {
+    println(s"Hello, ${args(0)}")
+    println(s"Hello 2, ${args(0)}")
+  }
+}
+
+trait Something
+object Main2 extends Something{
+  def main(args: Array[String]): Unit = {
+    println(s"Hello, ${args(0)}")
+    println(s"Hello 2, ${args(0)}")
+  }
+}
+
+object Main3 extends Something{
+  def main(args: Array[String]): Unit = {
+    println(s"Hello, ${args(0)}")
+    println(s"Hello 2, ${args(0)}")
+  }
+}
+
+object Main4 extends Something
+
+object Main5 extends Something {}
+
+object Main6
+  extends Something
+
+object Main7
+  extends Something
+
+object Main8
+  extends Something
+
+object Main9 extends
+  Something
+
+import scala.{ App => Ppa }
+object Main10 extends Something {
+  def main(args: Array[String]): Unit = {
+    println(s"Hello, ${args(0)}")
+    println(s"Hello 2, ${args(0)}")
+  }
+}
+
+object Main11 {
+  def main(args: Array[String]): Unit = { println(args(0)) }
+}