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 {

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

@@ -67,7 +67,8 @@ trait SymDenotations { this: Context =>
       || (owner.unforcedDecls.lookupAll(denot.name) contains denot.symbol)
       || denot.isSelfSym
       || denot.isLocalDummy)
-  } catch {
+  }
+  catch {
     case ex: StaleSymbol => false
   }
 

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

@@ -340,7 +340,8 @@ abstract class SymbolLoader extends LazyType { self =>
       else
         doComplete(root)
       ctx.informTime("loaded " + description, start)
-    } catch {
+    }
+    catch {
       case ex: IOException =>
         signalError(ex)
       case NonFatal(ex: TypeError) =>
@@ -349,11 +350,13 @@ abstract class SymbolLoader extends LazyType { self =>
       case NonFatal(ex) =>
         println(s"exception caught when loading $root: $ex")
         throw ex
-    } finally {
-      def postProcess(denot: SymDenotation) =
+    }
+    finally {
+      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/TypeOps.scala

@@ -89,7 +89,7 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
         }
       }
 
-      /*>|>*/ trace.conditionally(TypeOps.track, s"asSeen ${tp.show} from (${pre.show}, ${cls.show})", show = true) /*<|<*/ { // !!! DEBUG
+      trace.conditionally(TypeOps.track, s"asSeen ${tp.show} from (${pre.show}, ${cls.show})", show = true) { // !!! DEBUG
         // All cases except for ThisType are the same as in Map. Inlined for performance
         // TODO: generalize the inlining trick?
         tp match {
@@ -649,16 +649,14 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
       parent.argInfos.nonEmpty && minTypeMap.apply(parent) <:< maxTypeMap.apply(tp2)
     }
 
-    if (protoTp1 <:< tp2) {
+    if (protoTp1 <:< tp2)
       if (isFullyDefined(protoTp1, force)) protoTp1
       else instUndetMap.apply(protoTp1)
-    }
     else {
       val protoTp2 = maxTypeMap.apply(tp2)
-      if (protoTp1 <:< protoTp2 || parentQualify) {
+      if (protoTp1 <:< protoTp2 || parentQualify)
         if (isFullyDefined(AndType(protoTp1, protoTp2), force)) protoTp1
         else instUndetMap.apply(protoTp1)
-      }
       else {
         typr.println(s"$protoTp1 <:< $protoTp2 = false")
         NoType

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

@@ -1869,10 +1869,9 @@ object Types {
      *  Assumes that symbols do not change between periods in the same run.
      *  Used to get the class underlying a ThisType.
      */
-    private[Types] def stableInRunSymbol(implicit ctx: Context): Symbol = {
+    private[Types] def stableInRunSymbol(implicit ctx: Context): Symbol =
       if (checkedPeriod.runId == ctx.runId) lastSymbol
       else symbol
-    }
 
     def info(implicit ctx: Context): Type = denot.info
 
@@ -2008,9 +2007,10 @@ 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
@@ -2107,9 +2107,9 @@ object Types {
         } finally {
           ctx.pendingUnderlying -= this
         }
-    } finally {
-      ctx.base.underlyingRecursions -= 1
     }
+    finally
+      ctx.base.underlyingRecursions -= 1
 
     /** The argument corresponding to class type parameter `tparam` as seen from
      *  prefix `pre`. Can produce a TypeBounds type in case prefix is an & or | type
@@ -3139,19 +3139,18 @@ object Types {
      *    def f(x: C)(y: x.T)       // dependencyStatus = FalseDeps, i.e.
      *                              // dependency can be eliminated by dealiasing.
      */
-    private def dependencyStatus(implicit ctx: Context): DependencyStatus = {
+    private def dependencyStatus(implicit ctx: Context): DependencyStatus =
       if (myDependencyStatus != Unknown) myDependencyStatus
       else {
         val result = depStatus(NoDeps, resType)
         if ((result & Provisional) == 0) myDependencyStatus = result
         (result & StatusMask).toByte
       }
-    }
 
     /** The parameter dependency status of this method. Analogous to `dependencyStatus`,
      *  but tracking dependencies in same parameter list.
      */
-    private def paramDependencyStatus(implicit ctx: Context): DependencyStatus = {
+    private def paramDependencyStatus(implicit ctx: Context): DependencyStatus =
       if (myParamDependencyStatus != Unknown) myParamDependencyStatus
       else {
         val result =
@@ -3160,7 +3159,6 @@ object Types {
         if ((result & Provisional) == 0) myParamDependencyStatus = result
         (result & StatusMask).toByte
       }
-    }
 
     /** Does result type contain references to parameters of this method type,
      *  which cannot be eliminated by de-aliasing?
@@ -4722,7 +4720,7 @@ object Types {
      *  If the expansion is a wildcard parameter reference, convert its
      *  underlying bounds to a range, otherwise return the expansion.
      */
-    def expandParam(tp: NamedType, pre: Type): Type = {
+    def expandParam(tp: NamedType, pre: Type): Type =
       tp.argForParam(pre) match {
         case arg @ TypeRef(pre, _) if pre.isArgPrefixOf(arg.symbol) =>
           arg.info match {
@@ -4732,7 +4730,6 @@ object Types {
         case arg: TypeBounds => expandBounds(arg)
         case arg => reapply(arg)
       }
-    }
 
     /** Derived selection.
      *  @pre   the (upper bound of) prefix `pre` has a member named `tp.name`.
@@ -4858,9 +4855,8 @@ object Types {
           if (underlying.isBottomType) underlying
           else tp.derivedAnnotatedType(underlying, annot)
       }
-    override protected def derivedWildcardType(tp: WildcardType, bounds: Type): WildcardType = {
+    override protected def derivedWildcardType(tp: WildcardType, bounds: Type): WildcardType =
       tp.derivedWildcardType(rangeToBounds(bounds))
-    }
 
     override protected def derivedSkolemType(tp: SkolemType, info: Type): Type = info match {
       case Range(lo, hi) =>

compiler/src/dotty/tools/dotc/interactive/Completion.scala

@@ -293,9 +293,8 @@ object Completion {
           addMember(imp.site, name.toTypeName, nameInScope.toTypeName)
         }
         imp.reverseMapping.foreachBinding { (nameInScope, original) =>
-          if (original != nameInScope || !imp.excluded.contains(original)) {
+          if (original != nameInScope || !imp.excluded.contains(original))
             addImport(original, nameInScope)
-          }
         }
         if (imp.isWildcardImport)
           for (mbr <- accessibleMembers(imp.site) if !imp.excluded.contains(mbr.name.toTermName))

compiler/src/dotty/tools/dotc/interactive/InteractiveDriver.scala

@@ -236,7 +236,8 @@ class InteractiveDriver(val settings: List[String]) extends Driver {
             for {
               tastySuffix <- tastySuffixes
               if name.endsWith(tastySuffix)
-            } {
+            }
+            {
               buffer += dir.relativize(path).toString.replace("/", ".").stripSuffix(tastySuffix).toTypeName
             }
           }