Make files invariant under rewriting

Author: odersky

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

@@ -72,22 +72,21 @@ class Driver {
       // Resolve classpath and class names of tasty files
       val (classPaths, classNames) = fileNames0.flatMap { name =>
         val path = Paths.get(name)
-        if (name.endsWith(".jar")) {
+        if (name.endsWith(".jar"))
           new dotty.tools.io.Jar(File(name)).toList.collect {
             case e if e.getName.endsWith(".tasty") =>
               (name, e.getName.stripSuffix(".tasty").replace("/", "."))
           }
-        }
         else if (!name.endsWith(".tasty"))
           ("", name) :: Nil
-        else if (Files.exists(path)) {
+        else if (Files.exists(path))
           TastyFileUtil.getClassName(path) match {
             case Some(res) => res:: Nil
             case _ =>
               ctx0.error(s"Could not load classname from $name.")
               ("", name) :: Nil
           }
-        } else {
+        else {
           ctx0.error(s"File $name does not exist.")
           ("", name) :: Nil
         }

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

@@ -454,8 +454,9 @@ object desugar {
         if (isCaseClass)
           ctx.error(CaseClassMissingParamList(cdef), namePos)
         ListOfNil
-      } else if (isCaseClass && originalVparamss.head.exists(_.mods.isOneOf(GivenOrImplicit))) {
-          ctx.error("Case classes should have a non-implicit parameter list", namePos)
+      }
+      else if (isCaseClass && originalVparamss.head.exists(_.mods.isOneOf(GivenOrImplicit))) {
+        ctx.error("Case classes should have a non-implicit parameter list", namePos)
         ListOfNil
       }
       else originalVparamss.nestedMap(toDefParam(_, keepAnnotations = false))
@@ -717,12 +718,11 @@ object desugar {
       }
       else if (companionMembers.nonEmpty || companionDerived.nonEmpty || isEnum)
         companionDefs(anyRef, companionMembers)
-      else if (isValueClass) {
+      else if (isValueClass)
         impl.constr.vparamss match {
           case (_ :: Nil) :: _ => companionDefs(anyRef, Nil)
           case _ => Nil // error will be emitted in typer
         }
-      }
       else Nil
 
     enumCompanionRef match {
@@ -1129,12 +1129,11 @@ object desugar {
     case tree: MemberDef =>
       var tested: MemberDef = tree
       def fail(msg: String) = ctx.error(msg, tree.sourcePos)
-      def checkApplicable(flag: Flag, test: MemberDefTest): Unit = {
+      def checkApplicable(flag: Flag, test: MemberDefTest): Unit =
         if (tested.mods.is(flag) && !test.applyOrElse(tree, (md: MemberDef) => false)) {
           fail(i"modifier `${flag.flagsString}` is not allowed for this definition")
           tested = tested.withMods(tested.mods.withoutFlags(flag))
         }
-      }
       checkApplicable(Opaque, legalOpaque)
       tested
     case _ =>

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

@@ -42,7 +42,8 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
           if (param.info.isRepeatedParam) {
             for (arg <- args) f(param, arg)
             true
-          } else args match {
+          }
+          else args match {
             case Nil => false
             case arg :: args1 =>
               f(param, args.head)

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

@@ -1467,7 +1467,7 @@ object Trees {
             case _ =>
               foldMoreCases(x, tree)
           }
-      }
+        }
 
       def foldMoreCases(x: X, tree: Tree)(implicit ctx: Context): X = {
         assert(ctx.reporter.errorsReported || ctx.mode.is(Mode.Interactive), tree)

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

@@ -107,7 +107,8 @@ class CheckRealizable(implicit ctx: Context) {
           if (tp.info.isStable && tpInfoRealizable == Realizable) {
             sym.setFlag(StableRealizable)
             Realizable
-          } else r
+          }
+          else r
         }
       }
     case _: SingletonType | NoPrefix =>

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

@@ -371,9 +371,8 @@ 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/Names.scala

@@ -390,7 +390,7 @@ object Names {
     override def toString: String =
       if (length == 0) ""
       else {
-        if (Config.checkBackendNames) {
+        if (Config.checkBackendNames)
           if (!toStringOK) {
             // We print the stacktrace instead of doing an assert directly,
             // because asserts are caught in exception handlers which might
@@ -400,7 +400,6 @@ object Names {
             Thread.dumpStack()
             assert(false)
           }
-        }
         new String(chrs, start, length)
       }
 

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

@@ -484,12 +484,11 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
 
   def foreachTypeVar(op: TypeVar => Unit): Unit =
     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 => op(tv)
           case _ =>
         }
-      }
     }
 
   def & (other: Constraint, otherHasErrors: Boolean)(implicit ctx: Context): OrderingConstraint = {

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

@@ -86,18 +86,19 @@ trait SymDenotations { this: Context =>
         else {
           implicit val ctx = this
           val initial = denot.initial
-          if ((initial ne denot) || ctx.phaseId != initial.validFor.firstPhaseId) {
+          if ((initial ne denot) || ctx.phaseId != initial.validFor.firstPhaseId)
             ctx.withPhase(initial.validFor.firstPhaseId).traceInvalid(initial)
-          } else try {
+          else try {
             val owner = denot.owner.denot
             if (!traceInvalid(owner)) explainSym("owner is invalid")
             else if (!owner.isClass || owner.isRefinementClass || denot.isSelfSym) true
             else if (owner.unforcedDecls.lookupAll(denot.name) contains denot.symbol) true
             else explainSym(s"decls of ${show(owner)} are ${owner.unforcedDecls.lookupAll(denot.name).toList}, do not contain ${denot.symbol}")
-          } catch {
+          }
+          catch {
             case ex: StaleSymbol => explainSym(s"$ex was thrown")
           }
-      }
+        }
       case _ =>
         explain("denotation is not a SymDenotation")
     }

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

@@ -466,7 +466,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
 
       case _ =>
         val cls2 = tp2.symbol
-        if (cls2.isClass) {
+        if (cls2.isClass)
           if (cls2.typeParams.isEmpty) {
             if (cls2 eq AnyKindClass) return true
             if (tp1.isRef(NothingClass)) return true
@@ -485,7 +485,6 @@ class TypeComparer(initctx: Context) extends ConstraintHandling[AbsentContext] w
           }
           else if (tp1.isLambdaSub && !tp1.isRef(AnyKindClass))
             return recur(tp1, EtaExpansion(cls2.typeRef))
-        }
         fourthTry
     }