Don't always enclose partial ofs in braces

This needs to be done only if the partial if is followed by `else`.

Change all dotc code to be stable under the new rewrite scheme.

Author: odersky

compiler/src/dotty/tools/dotc/Run.scala

@@ -115,12 +115,11 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
    *  or we need to assemble phases on each run, and take -Yskip, -Ystop into
    *  account. I think the latter would be preferable.
    */
-  def compileSources(sources: List[SourceFile]): Unit = {
+  def compileSources(sources: List[SourceFile]): Unit =
     if (sources forall (_.exists)) {
       units = sources.map(CompilationUnit(_))
       compileUnits()
     }
-  }
 
   def compileUnits(us: List[CompilationUnit]): Unit = {
     units = us
@@ -152,7 +151,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
       var lastPrintedTree: PrintedTree = NoPrintedTree
       val profiler = ctx.profiler
 
-      for (phase <- ctx.base.allPhases) {
+      for (phase <- ctx.base.allPhases)
         if (phase.isRunnable)
           Stats.trackTime(s"$phase ms ") {
             val start = System.currentTimeMillis
@@ -168,7 +167,6 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
             for (unit <- units)
               Stats.record(s"retained typed trees at end of $phase", unit.tpdTree.treeSize)
           }
-      }
 
       profiler.finished()
     }
@@ -190,7 +188,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
    *  If `typeCheck = true`, also run typer on the compilation unit, and set
    *  `rootTreeOrProvider`.
    */
-  def lateCompile(file: AbstractFile, typeCheck: Boolean)(implicit ctx: Context): Unit = {
+  def lateCompile(file: AbstractFile, typeCheck: Boolean)(implicit ctx: Context): Unit =
     if (!files.contains(file) && !lateFiles.contains(file)) {
       lateFiles += file
       val unit = CompilationUnit(ctx.getSource(file.path))
@@ -209,7 +207,6 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
       }
       process()(runContext.fresh.setCompilationUnit(unit))
     }
-  }
 
   private sealed trait PrintedTree
   private /*final*/ case class SomePrintedTree(phase: String, tree: String) extends PrintedTree

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -1697,9 +1697,8 @@ object desugar {
   private def getVariables(tree: Tree)(implicit ctx: Context): List[VarInfo] = {
     val buf = ListBuffer[VarInfo]()
     def seenName(name: Name) = buf exists (_._1.name == name)
-    def add(named: NameTree, t: Tree): Unit = {
+    def add(named: NameTree, t: Tree): Unit =
       if (!seenName(named.name) && named.name.isTermName) buf += ((named, t))
-    }
     def collect(tree: Tree): Unit = tree match {
       case Bind(nme.WILDCARD, tree1) =>
         collect(tree1)

compiler/src/dotty/tools/dotc/ast/Trees.scala

@@ -118,7 +118,7 @@ object Trees {
      *   - the child tree is an identifier, or
      *   - errors were reported
      */
-    private def checkChildrenTyped(it: Iterator[Any])(implicit ctx: Context): Unit = {
+    private def checkChildrenTyped(it: Iterator[Any])(implicit ctx: Context): Unit =
       if (!this.isInstanceOf[Import[_]])
         while (it.hasNext)
           it.next() match {
@@ -129,7 +129,6 @@ object Trees {
             case xs: List[_] => checkChildrenTyped(xs.iterator)
             case _ =>
           }
-    }
 
     def withTypeUnchecked(tpe: Type): ThisTree[Type] = {
       val tree =

compiler/src/dotty/tools/dotc/classpath/DirectoryClassPath.scala

@@ -71,12 +71,11 @@ trait DirectoryLookup[FileEntryType <: ClassRepresentation] extends ClassPath {
     val packagePrefix = PackageNameUtils.packagePrefix(inPackage)
     val packageBuf = collection.mutable.ArrayBuffer.empty[PackageEntry]
     val fileBuf = collection.mutable.ArrayBuffer.empty[FileEntryType]
-    for (file <- files) {
+    for (file <- files)
       if (isPackage(file))
         packageBuf += PackageEntryImpl(packagePrefix + getName(file))
       else if (isMatchingFile(file))
         fileBuf += createFileEntry(toAbstractFile(file))
-    }
     ClassPathEntries(packageBuf, fileBuf)
   }
 }

compiler/src/dotty/tools/dotc/classpath/ZipArchiveFileLookup.scala

@@ -58,12 +58,11 @@ trait ZipArchiveFileLookup[FileEntryType <: ClassRepresentation] extends ClassPa
       val fileBuf = collection.mutable.ArrayBuffer.empty[FileEntryType]
       val prefix = PackageNameUtils.packagePrefix(inPackage)
 
-      for (entry <- dirEntry.iterator) {
+      for (entry <- dirEntry.iterator)
         if (entry.isPackage)
           pkgBuf += PackageEntryImpl(prefix + entry.name)
         else if (isRequiredFileType(entry))
           fileBuf += createFileEntry(entry)
-      }
       ClassPathEntries(pkgBuf, fileBuf)
     } getOrElse ClassPathEntries(Seq.empty, Seq.empty)
   }

compiler/src/dotty/tools/dotc/consumetasty/ConsumeTasty.scala

@@ -36,5 +36,5 @@ object ConsumeTasty {
       case _ => classpath0
     }
   }
-
 }
+

compiler/src/dotty/tools/dotc/core/ConstraintRunInfo.scala

@@ -7,12 +7,11 @@ import config.Printers.{default, typr}
 trait ConstraintRunInfo { self: Run =>
   private[this] var maxSize = 0
   private[this] var maxConstraint: Constraint = _
-  def recordConstraintSize(c: Constraint, size: Int): Unit = {
+  def recordConstraintSize(c: Constraint, size: Int): Unit =
     if (size > maxSize) {
       maxSize = size
       maxConstraint = c
     }
-  }
   def printMaxConstraint()(implicit ctx: Context): Unit = {
     val printer = if (ctx.settings.YdetailedStats.value) default else typr
     if (maxSize > 0) printer.println(s"max constraint = ${maxConstraint.show}")

compiler/src/dotty/tools/dotc/core/GadtConstraint.scala

@@ -317,9 +317,8 @@ final class ProperGadtConstraint private(
   override def approximation(sym: Symbol, fromBelow: Boolean)(implicit ctx: Context): Type = unsupported("EmptyGadtConstraint.approximation")
 
   override def fresh = new ProperGadtConstraint
-  override def restore(other: GadtConstraint): Unit = {
+  override def restore(other: GadtConstraint): Unit =
     if (!other.isEmpty) sys.error("cannot restore a non-empty GADTMap")
-  }
 
   override def debugBoundsDescription(implicit ctx: Context): String = "EmptyGadtConstraint"
 

compiler/src/dotty/tools/dotc/core/Names.scala

@@ -377,9 +377,8 @@ object Names {
     override def replace(from: Char, to: Char): SimpleName = {
       val cs = new Array[Char](length)
       System.arraycopy(chrs, start, cs, 0, length)
-      for (i <- 0 until length) {
+      for (i <- 0 until length)
         if (cs(i) == from) cs(i) = to
-      }
       termName(cs, 0, length)
     }
 
@@ -573,13 +572,12 @@ object Names {
     val h = hashValue(cs, offset, len) & (table.length - 1)
 
     /** Make sure the capacity of the character array is at least `n` */
-    def ensureCapacity(n: Int) = {
+    def ensureCapacity(n: Int) =
       if (n > chrs.length) {
         val newchrs = new Array[Char](chrs.length * 2)
         chrs.copyToArray(newchrs)
         chrs = newchrs
       }
-    }
 
     /** Enter characters into chrs array. */
     def enterChars(): Unit = {
@@ -593,15 +591,14 @@ object Names {
     }
 
     /** Rehash chain of names */
-    def rehash(name: SimpleName): Unit = {
+    def rehash(name: SimpleName): Unit =
       if (name != null) {
         val oldNext = name.next
         val h = hashValue(chrs, name.start, name.length) & (table.size - 1)
         name.next = table(h)
         table(h) = name
         rehash(oldNext)
       }
-    }
 
     /** Make sure the hash table is large enough for the given load factor */
     def incTableSize() = {

compiler/src/dotty/tools/dotc/core/OrderingConstraint.scala

@@ -588,10 +588,9 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
       case TypeParamRef(binder: TypeLambda, _) => !contains(binder)
       case _ => false
     }
-    def checkClosedType(tp: Type, where: String) = {
+    def checkClosedType(tp: Type, where: String) =
       if (tp != null)
         assert(!tp.existsPart(isFreeTypeParamRef), i"unclosed constraint: $this refers to $tp in $where")
-    }
     boundsMap.foreachBinding((_, tps) => tps.foreach(checkClosedType(_, "bounds")))
     lowerMap.foreachBinding((_, paramss) => paramss.foreach(_.foreach(checkClosedType(_, "lower"))))
     upperMap.foreachBinding((_, paramss) => paramss.foreach(_.foreach(checkClosedType(_, "upper"))))