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"))))

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

@@ -158,12 +158,11 @@ object Scopes {
      */
     final def filteredScope(p: Symbol => Boolean)(implicit ctx: Context): Scope = {
       var result: MutableScope = null
-      for (sym <- iterator) {
+      for (sym <- iterator)
         if (!p(sym)) {
           if (result == null) result = cloneScope
           result.unlink(sym)
         }
-      }
       if (result == null) this else result
     }
 
@@ -279,9 +278,8 @@ object Scopes {
       enter(sym)
     }
 
-    private def ensureCapacity(tableSize: Int)(implicit ctx: Context): Unit = {
+    private def ensureCapacity(tableSize: Int)(implicit ctx: Context): Unit =
       if (size >= tableSize * FillFactor) createHash(tableSize * 2)
-    }
 
     private def createHash(tableSize: Int)(implicit ctx: Context): Unit =
       if (size > tableSize * FillFactor) createHash(tableSize * 2)
@@ -291,7 +289,7 @@ object Scopes {
         // checkConsistent() // DEBUG
       }
 
-    private def enterAllInHash(e: ScopeEntry, n: Int = 0)(implicit ctx: Context): Unit = {
+    private def enterAllInHash(e: ScopeEntry, n: Int = 0)(implicit ctx: Context): Unit =
       if (e ne null)
         if (n < MaxRecursions) {
           enterAllInHash(e.prev, n + 1)
@@ -306,7 +304,6 @@ object Scopes {
           }
           entries foreach enterInHash
         }
-    }
 
     /** Remove entry from this scope (which is required to be present) */
     final def unlink(e: ScopeEntry)(implicit ctx: Context): Unit = {

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

@@ -1390,10 +1390,9 @@ object SymDenotations {
       case _ => false
     }
 
-    def assertNoSkolems(tp: Type): Unit = {
+    def assertNoSkolems(tp: Type): Unit =
       if (!this.isSkolem)
         assert(!hasSkolems(tp), s"assigning type $tp containing skolems to $this")
-    }
 
     // ----- copies and transforms  ----------------------------------------
 
@@ -2040,10 +2039,9 @@ object SymDenotations {
     private[this] var myCompanion: Symbol = NoSymbol
 
     /** Register companion class */
-    override def registerCompanion(companion: Symbol)(implicit ctx: Context) = {
+    override def registerCompanion(companion: Symbol)(implicit ctx: Context) =
       if (companion.isClass && !isAbsent(canForce = false) && !companion.isAbsent(canForce = false))
         myCompanion = companion
-    }
 
     override def registeredCompanion(implicit ctx: Context) = { ensureCompleted(); myCompanion }
     override def registeredCompanion_=(c: Symbol) = { myCompanion = c }
@@ -2163,12 +2161,11 @@ object SymDenotations {
     /** Unlink all package members defined in `file` in a previous run. */
     def unlinkFromFile(file: AbstractFile)(implicit ctx: Context): Unit = {
       val scope = unforcedDecls.openForMutations
-      for (sym <- scope.toList.iterator) {
+      for (sym <- scope.toList.iterator)
         // We need to be careful to not force the denotation of `sym` here,
         // otherwise it will be brought forward to the current run.
         if (sym.defRunId != ctx.runId && sym.isClass && sym.asClass.assocFile == file)
           scope.unlink(sym, sym.lastKnownDenotation.name)
-      }
     }
   }
 
@@ -2370,14 +2367,13 @@ object SymDenotations {
      *  the cache itself. In that case we should cancel invalidation and
      *  proceed as usual. However, all cache entries should be cleared.
      */
-    def invalidate(): Unit = {
+    def invalidate(): Unit =
       if (cache != null)
         if (locked) cache = SimpleIdentityMap.Empty
         else {
           cache = null
           invalidateDependents()
         }
-    }
 
     def apply(keepOnly: NameFilter, clsd: ClassDenotation)(implicit onBehalf: MemberNames, ctx: Context) = {
       assert(isValid)
@@ -2407,13 +2403,12 @@ object SymDenotations {
 
     final def isValid(implicit ctx: Context): Boolean = valid && isValidAt(ctx.phase)
 
-    def invalidate(): Unit = {
+    def invalidate(): Unit =
       if (valid && !locked) {
         cache = null
         valid = false
         invalidateDependents()
       }
-    }
 
     def signalProvisional() = provisional = true
 

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

@@ -260,16 +260,14 @@ object SymbolLoaders {
       if (!root.isRoot) {
         val classReps = classPath.list(packageName).classesAndSources
 
-        for (classRep <- classReps) {
+        for (classRep <- classReps)
           if (!maybeModuleClass(classRep) && hasFlatName(classRep) == flat &&
             (!flat || isAbsent(classRep))) // on 2nd enter of flat names, check that the name has not been entered before
             initializeFromClassPath(root.symbol, classRep)
-        }
-        for (classRep <- classReps) {
+        for (classRep <- classReps)
           if (maybeModuleClass(classRep) && hasFlatName(classRep) == flat &&
               isAbsent(classRep))
             initializeFromClassPath(root.symbol, classRep)
-        }
       }
     }
 
@@ -352,11 +350,10 @@ abstract class SymbolLoader extends LazyType { self =>
         throw ex
     }
     finally {
-      def postProcess(denot: SymDenotation) = {
+      def postProcess(denot: SymDenotation) =
         if (!denot.isCompleted &&
             !denot.completer.isInstanceOf[SymbolLoaders.SecondCompleter])
           denot.markAbsent()
-      }
       postProcess(root)
       if (!root.isRoot)
         postProcess(root.scalacLinkedClass.denot)

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

@@ -444,9 +444,8 @@ object Symbols {
       if (myDefTree == null) tpd.EmptyTree else myDefTree
 
     /** Set defining tree if this symbol retains its definition tree */
-    def defTree_=(tree: Tree)(implicit ctx: Context): Unit = {
+    def defTree_=(tree: Tree)(implicit ctx: Context): Unit =
       if (retainsDefTree) myDefTree = tree
-    }
 
     /** Does this symbol retain its definition tree?
      *  A good policy for this needs to balance costs and benefits, where

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

@@ -2007,10 +2007,9 @@ object Types {
       setDenot(memberDenot(name, allowPrivate = !symbol.exists || symbol.is(Private)))
 
     private def setDenot(denot: Denotation)(implicit ctx: Context): Unit = {
-      if (Config.checkNoDoubleBindings) {
+      if (Config.checkNoDoubleBindings)
         if (ctx.settings.YnoDoubleBindings.value)
           checkSymAssign(denot.symbol)
-      }
 
       lastDenotation = denot
       lastSymbol = denot.symbol
@@ -2361,9 +2360,8 @@ object Types {
   }
 
   /** Assert current phase does not have erasure semantics */
-  private def assertUnerased()(implicit ctx: Context) = {
+  private def assertUnerased()(implicit ctx: Context) =
     if (Config.checkUnerased) assert(!ctx.phase.erasedTypes)
-  }
 
   /** The designator to be used for a named type creation with given prefix, name, and denotation.
    *  This is the denotation's symbol, if it exists and the prefix is not the this type
@@ -2844,7 +2842,7 @@ object Types {
     private[this] var myAtoms: Set[Type] = _
     private[this] var myWidened: Type = _
 
-    private def ensureAtomsComputed()(implicit ctx: Context): Unit = {
+    private def ensureAtomsComputed()(implicit ctx: Context): Unit =
       if (atomsRunId != ctx.runId) {
         val atoms1 = tp1.atoms
         val atoms2 = tp2.atoms
@@ -2854,7 +2852,6 @@ object Types {
         myWidened = if ((tp1 eq tp1w) && (tp2 eq tp2w)) this else tp1w | tp2w
         atomsRunId = ctx.runId
       }
-    }
 
     override def atoms(implicit ctx: Context): Set[Type] = {
       ensureAtomsComputed()