Reorganize rewrite flags

and fixes to rewrite rules in Parser

# Conflicts:
#	compiler/src/dotty/tools/dotc/parsing/Scanners.scala

Author: odersky

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -25,8 +25,6 @@ class ScalaSettings extends Settings.SettingGroup {
   val priorityclasspath: Setting[String] = PathSetting("-priorityclasspath", "class path that takes precedence over all other paths (or testing only)", "") withAbbreviation "--priority-class-path"
 
   /** Other settings */
-  val cleansyntax: Setting[Boolean] = BooleanSetting("-cleansyntax", "allow control expressions without parentheses")
-  val revertClean: Setting[Boolean] = BooleanSetting("-revertclean", "when used with -rewrite, rewrite from clean syntax to classical (...) syntax")
   val deprecation: Setting[Boolean] = BooleanSetting("-deprecation", "Emit warning and location for usages of deprecated APIs.") withAbbreviation "--deprecation"
   val migration: Setting[Boolean] = BooleanSetting("-migration", "Emit warning and location for migration issues from Scala 2.") withAbbreviation "--migration"
   val encoding: Setting[String] = StringSetting("-encoding", "encoding", "Specify character encoding used by source files.", Properties.sourceEncoding) withAbbreviation "--encoding"
@@ -50,6 +48,9 @@ class ScalaSettings extends Settings.SettingGroup {
   val silentWarnings: Setting[Boolean] = BooleanSetting("-nowarn", "Silence all warnings.") withAbbreviation "--no-warnings"
   val fromTasty: Setting[Boolean] = BooleanSetting("-from-tasty", "Compile classes from tasty in classpath. The arguments are used as class names.") withAbbreviation "--from-tasty"
 
+  val cStyle: Setting[Boolean] = BooleanSetting("-c-style", "when used with -rewrite, produces control expressions with parentheses")
+  val pascalStyle: Setting[Boolean] = BooleanSetting("-pascal-style", "when used with -rewrite, produces control expressions without parentheses")
+
   /** Decompiler settings */
   val printTasty: Setting[Boolean] = BooleanSetting("-print-tasty", "Prints the raw tasty.") withAbbreviation "--print-tasty"
   val printLines: Setting[Boolean] = BooleanSetting("-print-lines", "Show source code line numbers.") withAbbreviation "--print-lines"

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -576,12 +576,13 @@ object Parsers {
     /** Drop (...) or { ... }, replacing the closing element with `endStr` */
     def dropParensOrBraces(start: Offset, endStr: String): Unit = {
       patch(source, Span(start, start + 1), "")
-      val filler = if (in.lastOffset == in.offset) " " else ""
       val closingStartsLine = testChar(skipBlanks(in.lastOffset - 2, -1), Chars.LF)
+      val preFill = if (closingStartsLine || endStr.isEmpty) "" else " "
+      val postFill = if (in.lastOffset == in.offset) " " else ""
       val (startClosing, endClosing) =
         if (closingStartsLine && endStr.isEmpty) closingElimRegion()
         else (in.lastOffset - 1, in.lastOffset)
-      patch(source, Span(startClosing, endClosing), s"$endStr$filler")
+      patch(source, Span(startClosing, endClosing), s"$preFill$endStr$postFill")
     }
 
     /** rewrite code with (...) around the source code of `t` */
@@ -1346,19 +1347,21 @@ object Parsers {
       if (in.token == LPAREN) {
         var t: Tree = atSpan(in.offset) { Parens(inParens(exprInParens())) }
         if (in.token != altToken && followedByToken(altToken))
-          t = inSepRegion(LPAREN, RPAREN)(
-            expr1Rest(postfixExprRest(simpleExprRest(t)), Location.ElseWhere))
+          t = inSepRegion(LPAREN, RPAREN) {
+            newLineOpt()
+            expr1Rest(postfixExprRest(simpleExprRest(t)), Location.ElseWhere)
+          }
         if (in.token == altToken) {
           in.nextToken()
-          if (in.revertCleanRewrite) revertToParens(t)
+          if (in.rewriteC) revertToParens(t)
         }
-        else if (in.cleanRewrite)
-          dropParensOrBraces(t.span.start, s" ${tokenString(altToken)}")
+        else if (in.rewritePascal)
+          dropParensOrBraces(t.span.start, s"${tokenString(altToken)}")
         t
       } else {
         val t = inSepRegion(LPAREN, RPAREN)(expr())
         accept(altToken)
-        if (in.revertCleanRewrite) revertToParens(t)
+        if (in.rewriteC) revertToParens(t)
         t
       }
     }
@@ -1451,7 +1454,7 @@ object Parsers {
         in.errorOrMigrationWarning(
           i"""`do <body> while <cond>' is no longer supported,
              |use `while ({<body> ; <cond>}) ()' instead.
-             |The statement can be rewritten automatically under -language:Scala2 -migration -rewrite.
+             |The statement can be rewritten automatically under -language:Scala2 -rewrite.
            """)
         val start = in.skipToken()
         atSpan(start) {
@@ -1460,7 +1463,7 @@ object Parsers {
           val whileStart = in.offset
           accept(WHILE)
           val cond = expr()
-          if (ctx.settings.migration.value) {
+          if (in.isScala2Mode) {
             patch(source, Span(start, start + 2), "while ({")
             patch(source, Span(whileStart, whileStart + 5), ";")
             cond match {
@@ -1919,8 +1922,13 @@ object Parsers {
     def enumerators(): List[Tree] = generator() :: enumeratorsRest()
 
     def enumeratorsRest(): List[Tree] =
-      if (isStatSep) { in.nextToken(); enumerator() :: enumeratorsRest() }
-      else if (in.token == IF) guard() :: enumeratorsRest()
+      if (isStatSep) {
+        in.nextToken()
+        if (in.token == DO || in.token == YIELD || in.token == RBRACE) Nil
+        else enumerator() :: enumeratorsRest()
+      }
+      else if (in.token == IF)
+        guard() :: enumeratorsRest()
       else Nil
 
     /** Enumerator  ::=  Generator
@@ -1959,62 +1967,76 @@ object Parsers {
     def forExpr(): Tree = atSpan(in.skipToken()) {
       var wrappedEnums = true
       val start = in.offset
-      val oldSyntax = in.token == LBRACE || in.token == LPAREN && parensEncloseGenerators
+      val forEnd = in.lastOffset
+      val leading = in.token
       val enums =
-        if (oldSyntax)
-          if (in.token == LBRACE)
-            inBraces(enumerators())
-          else {
-            val lparenOffset = in.skipToken()
-            openParens.change(LPAREN, 1)
-            val res =
-              if (in.token == CASE) enumerators()
-              else {
-                val pats = patternsOpt()
-                val pat =
-                  if (in.token == RPAREN || pats.length > 1) {
-                    wrappedEnums = false
-                    accept(RPAREN)
-                    openParens.change(LPAREN, -1)
-                    atSpan(lparenOffset) { makeTupleOrParens(pats) } // note: alternatives `|' need to be weeded out by typer.
-                  }
-                  else pats.head
-                generatorRest(pat, casePat = false) :: enumeratorsRest()
-              }
-            if (wrappedEnums) {
-              accept(RPAREN)
-              openParens.change(LPAREN, -1)
+        if (leading == LBRACE || leading == LPAREN && parensEncloseGenerators) {
+          var enumsOnNewLine = in.isAfterLineEnd() // if true, enums start on new line after `for`, so newlines are significant under Pascal-style syntax
+          in.nextToken()
+          enumsOnNewLine |= in.isAfterLineEnd()
+          openParens.change(leading, 1)
+          val res =
+            if (leading == LBRACE || in.token == CASE)
+              enumerators()
+            else {
+              val pats = patternsOpt()
+              val pat =
+                if (in.token == RPAREN || pats.length > 1) {
+                  wrappedEnums = false
+                  accept(RPAREN)
+                  openParens.change(LPAREN, -1)
+                  atSpan(start) { makeTupleOrParens(pats) } // note: alternatives `|' need to be weeded out by typer.
+                }
+                else pats.head
+              generatorRest(pat, casePat = false) :: enumeratorsRest()
+            }
+          if (wrappedEnums) {
+            val closingOnNewLine = in.isAfterLineEnd()
+            accept(leading + 1)
+            openParens.change(leading, -1)
+            if (in.rewritePascal && enumsOnNewLine == (leading == LBRACE)) { // Don't rewrite if that would change meaning of newlines
+              newLinesOpt()
+              dropParensOrBraces(start, if (in.token == YIELD || in.token == DO) "" else "do")
             }
-            res
           }
+          res
+        }
         else {
           wrappedEnums = false
-
-          /*if (in.token == INDENT) inBracesOrIndented(enumerators())
-          else*/ {
-            val ts = // If we use indent syntax, the distinction below should no longer be necessary
-              if (in.isAfterLineEnd()) enumerators()
-              else inSepRegion(LPAREN, RPAREN)(enumerators())
-            if (in.revertCleanRewrite && ts.nonEmpty) {
+          val impliedBraces = in.isAfterLineEnd()
+
+          /*if (in.token == INDENT) inBracesOrIndented(enumerators()) else*/
+          val ts = // If we use indent syntax, the distinction below should no longer be necessary
+            if (impliedBraces) enumerators()
+            else inSepRegion(LPAREN, RPAREN)(enumerators())
+          if (in.rewriteC && ts.nonEmpty) {
+            if (impliedBraces) {
+              patch(source, Span(forEnd), " {")
+              patch(source, Span(in.offset), "} ")
+            }
+            else {
               patch(source, ts.head.span.startPos, "(")
               patch(source, ts.last.span.endPos, ")")
             }
-            ts
           }
+          ts
         }
-      if (in.cleanRewrite && oldSyntax) {
-        dropParensOrBraces(start, if (in.token == YIELD) "" else " do")
-      }
       newLinesOpt()
       if (in.token == YIELD) {
         in.nextToken()
         ForYield(enums, expr())
       }
       else if (in.token == DO) {
-        if (in.revertCleanRewrite) {
-          var endPos = in.lastCharOffset
-          //if (testChar(endPos, ' ')) endPos += 1
-          patch(source, Span(in.offset - 1, endPos), "")
+        if (in.rewriteC) {
+          var startOffset = in.offset
+          var endOffset = in.lastCharOffset
+          if (in.isAfterLineEnd()) {
+            if (testChar(endOffset, ' ')) endOffset += 1
+          }
+          else {
+            if (testChar(startOffset - 1, ' ')) startOffset -= 1
+          }
+          patch(source, Span(startOffset, endOffset), "")
         }
         in.nextToken()
         ForDo(enums, expr())
@@ -2147,6 +2169,7 @@ object Parsers {
       case _ =>
         if (isLiteral) literal(inPattern = true)
         else {
+          println(i"$in found")
           syntaxErrorOrIncomplete(IllegalStartOfSimplePattern(), expectedOffset)
           errorTermTree
         }

compiler/src/dotty/tools/dotc/parsing/Scanners.scala

@@ -222,9 +222,9 @@ object Scanners {
     /** A switch whether operators at the start of lines can be infix operators */
     private var allowLeadingInfixOperators = true
 
-    private val rewrite = ctx.settings.rewrite.value.isDefined
-    val cleanRewrite = ctx.settings.cleansyntax.value && rewrite
-    val revertCleanRewrite = ctx.settings.revertClean.value && rewrite
+    val rewrite = ctx.settings.rewrite.value.isDefined
+    val rewritePascal = rewrite && ctx.settings.pascalStyle.value
+    val rewriteC = rewrite && ctx.settings.cStyle.value
 
     /** All doc comments kept by their end position in a `Map` */
     private[this] var docstringMap: SortedMap[Int, Comment] = SortedMap.empty

tests/pos/syntaxRewrites.scala

@@ -0,0 +1,69 @@
+object Test {
+
+  val xs = List(1, 2, 3)
+
+  for (x <- xs) yield x * 2
+
+  for (x <- xs)
+  yield x * 2
+
+  for { x <- xs; y <- xs } yield x * y
+
+  for {
+    x <- xs
+    y <- xs
+  } yield x * y
+
+  for {
+    x <- xs
+    y <- xs
+  } yield x * y
+
+  for { x <- xs }
+  yield x * 2
+
+// -----------------------------------------------
+
+  for (x <- xs) println(x)
+
+  for (x <- xs)
+    println(x)
+
+  for { x <- xs; y <- xs } println(x * y)
+
+  for {
+    x <- xs
+    y <- xs
+  }
+  println(x * y)
+
+  for {
+    x <- xs
+    y <- xs
+  } println(x * y)
+
+  for { x <- xs }
+    println(x)
+
+  if (xs == Nil) println("yes")
+
+  if (xs == Nil)
+    println("yes")
+
+  if (xs == Nil
+     && xs.length == 0)
+    println("yes")
+
+  while (xs == Nil) println("yes")
+
+  while ({
+    val ys = xs ++ xs
+    ys.nonEmpty
+  }) println("yes")
+
+  while ({
+    val ys = xs ++ xs
+    ys.nonEmpty
+  })
+  println("yes")
+}