More invariant rewritings

Additional rewritings to make the compiler source invariant if we also rewrite under braces

Author: odersky

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

@@ -45,7 +45,7 @@ object MainProxies {
     def pos = mainFun.sourcePos
     val argsRef = Ident(nme.args)
 
-    def addArgs(call: untpd.Tree, mt: MethodType, idx: Int): untpd.Tree = {
+    def addArgs(call: untpd.Tree, mt: MethodType, idx: Int): untpd.Tree =
       if (mt.isImplicitMethod) {
         ctx.error(s"@main method cannot have implicit parameters", pos)
         call
@@ -71,7 +71,6 @@ object MainProxies {
             call1
         }
       }
-    }
 
     var result: List[TypeDef] = Nil
     if (!mainFun.owner.isStaticOwner)

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

@@ -686,15 +686,14 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
   def defPath(sym: Symbol, root: Tree)(implicit ctx: Context): List[Tree] = trace.onDebug(s"defpath($sym with position ${sym.span}, ${root.show})") {
     require(sym.span.exists, sym)
     object accum extends TreeAccumulator[List[Tree]] {
-      def apply(x: List[Tree], tree: Tree)(implicit ctx: Context): List[Tree] = {
+      def apply(x: List[Tree], tree: Tree)(implicit ctx: Context): List[Tree] =
         if (tree.span.contains(sym.span))
           if (definedSym(tree) == sym) tree :: x
           else {
             val x1 = foldOver(x, tree)
             if (x1 ne x) tree :: x1 else x1
           }
         else x
-      }
     }
     accum(Nil, root)
   }

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

@@ -189,9 +189,8 @@ class TreeTypeMap(
       val origDcls = cls.info.decls.toList
       val mappedDcls = ctx.mapSymbols(origDcls, tmap)
       val tmap1 = tmap.withMappedSyms(origDcls, mappedDcls)
-      if (symsChanged) {
+      if (symsChanged)
         origDcls.lazyZip(mappedDcls).foreach(cls.asClass.replace)
-      }
       tmap1
     }
     if (symsChanged || (fullMap eq substMap)) fullMap

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

@@ -67,9 +67,9 @@ case class AggregateClassPath(aggregates: Seq[ClassPath]) extends ClassPath {
   override private[dotty] def hasPackage(pkg: String): Boolean = aggregates.exists(_.hasPackage(pkg))
   override private[dotty] def list(inPackage: String): ClassPathEntries = {
     val (packages, classesAndSources) = aggregates.map { cp =>
-      try {
+      try
         cp.list(inPackage).toTuple
-      } catch {
+      catch {
         case ex: java.io.IOException =>
           val e = new FatalError(ex.getMessage)
           e.initCause(ex)

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

@@ -371,8 +371,9 @@ object Comments {
                 superComment(sym) foreach { sc =>
                   val superSections = tagIndex(sc)
                   replaceWith(sc.substring(3, startTag(sc, superSections)))
-                  for (sec @ (start, end) <- superSections)
+                  for (sec @ (start, end) <- superSections) {
                     if (!isMovable(sc, sec)) out append sc.substring(start, end)
+                  }
                 }
               case "" => idx += 1
               case vname  =>

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

@@ -7,11 +7,12 @@ 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/Denotations.scala

@@ -1328,13 +1328,12 @@ object Denotations {
     def staticRef(path: Name, generateStubs: Boolean = true, isPackage: Boolean = false)(implicit ctx: Context): Denotation = {
       def select(prefix: Denotation, selector: Name): Denotation = {
         val owner = prefix.disambiguate(_.info.isParameterless)
-        def isPackageFromCoreLibMissing: Boolean = {
+        def isPackageFromCoreLibMissing: Boolean =
           owner.symbol == defn.RootClass &&
           (
             selector == nme.scala_ || // if the scala package is missing, the stdlib must be missing
             selector == nme.scalaShadowing // if the scalaShadowing package is missing, the dotty library must be missing
           )
-        }
         if (owner.exists) {
           val result = if (isPackage) owner.info.decl(selector) else owner.info.member(selector)
           if (result.exists) result

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

@@ -604,12 +604,11 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
     if (myUninstVars == null || myUninstVars.exists(_.inst.exists)) {
       myUninstVars = new mutable.ArrayBuffer[TypeVar]
       boundsMap.foreachBinding { (poly, entries) =>
-        for (i <- 0 until paramCount(entries)) {
+        for (i <- 0 until paramCount(entries))
           typeVar(entries, i) match {
             case tv: TypeVar if !tv.inst.exists && isBounds(entries(i)) => myUninstVars += tv
             case _ =>
           }
-        }
       }
     }
     myUninstVars

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

@@ -32,9 +32,8 @@ abstract class Periods { self: Context =>
   def stablePeriod: Period = {
     var first = phaseId
     val nxTrans = ctx.base.nextDenotTransformerId(first)
-    while (first - 1 > NoPhaseId && (ctx.base.nextDenotTransformerId(first - 1) == nxTrans)) {
+    while (first - 1 > NoPhaseId && (ctx.base.nextDenotTransformerId(first - 1) == nxTrans))
       first -= 1
-    }
     Period(runId, first, nxTrans)
   }
 

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

@@ -21,7 +21,7 @@ trait Substituters { this: Context =>
           .mapOver(tp)
     }
 
-  final def subst1(tp: Type, from: Symbol, to: Type, theMap: Subst1Map): Type = {
+  final def subst1(tp: Type, from: Symbol, to: Type, theMap: Subst1Map): Type =
     tp match {
       case tp: NamedType =>
         val sym = tp.symbol
@@ -34,9 +34,8 @@ trait Substituters { this: Context =>
         (if (theMap != null) theMap else new Subst1Map(from, to))
           .mapOver(tp)
     }
-  }
 
-  final def subst2(tp: Type, from1: Symbol, to1: Type, from2: Symbol, to2: Type, theMap: Subst2Map): Type = {
+  final def subst2(tp: Type, from1: Symbol, to1: Type, from2: Symbol, to2: Type, theMap: Subst2Map): Type =
     tp match {
       case tp: NamedType =>
         val sym = tp.symbol
@@ -50,9 +49,8 @@ trait Substituters { this: Context =>
         (if (theMap != null) theMap else new Subst2Map(from1, to1, from2, to2))
           .mapOver(tp)
     }
-  }
 
-  final def subst(tp: Type, from: List[Symbol], to: List[Type], theMap: SubstMap): Type = {
+  final def subst(tp: Type, from: List[Symbol], to: List[Type], theMap: SubstMap): Type =
     tp match {
       case tp: NamedType =>
         val sym = tp.symbol
@@ -71,7 +69,6 @@ trait Substituters { this: Context =>
         (if (theMap != null) theMap else new SubstMap(from, to))
           .mapOver(tp)
     }
-  }
 
   final def substSym(tp: Type, from: List[Symbol], to: List[Symbol], theMap: SubstSymMap): Type =
     tp match {