Ensure spaces after `if` in Dotty source.

23 files changed, 50 insertions, 50 deletions

diff --git a/src/dotty/tools/backend/jvm/CollectEntryPoints.scala b/src/dotty/tools/backend/jvm/CollectEntryPoints.scala
index 734890daa..513144bd6 100644
--- a/src/dotty/tools/backend/jvm/CollectEntryPoints.scala
+++ b/src/dotty/tools/backend/jvm/CollectEntryPoints.scala
@@ -40,7 +40,7 @@ class CollectEntryPoints extends MiniPhaseTransform {
   def phaseName: String = "Collect entry points"
 
   override def transformDefDef(tree: tpd.DefDef)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = {
-    if((tree.symbol ne NoSymbol) && CollectEntryPoints.isJavaEntyPoint(tree.symbol)) {
+    if ((tree.symbol ne NoSymbol) && CollectEntryPoints.isJavaEntyPoint(tree.symbol)) {
       ctx.genBCodePhase.asInstanceOf[GenBCode].registerEntryPoint(tree.symbol)
     }
     tree
diff --git a/src/dotty/tools/backend/jvm/DottyBackendInterface.scala b/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
index ee8d27137..e9c8dbc80 100644
--- a/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
+++ b/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
@@ -376,7 +376,7 @@ class DottyBackendInterface()(implicit ctx: Context) extends BackendInterface{
   def shouldEmitJumpAfterLabels = true
 
   def dumpClasses: Option[String] =
-    if(ctx.settings.Ydumpclasses.isDefault) None
+    if (ctx.settings.Ydumpclasses.isDefault) None
     else Some(ctx.settings.Ydumpclasses.value)
 
   def mainClass: Option[String] =
@@ -423,7 +423,7 @@ class DottyBackendInterface()(implicit ctx: Context) extends BackendInterface{
       case TermRef(prefix: ThisType, name) =>
         Some(tpd.This(prefix.cls).select(i.symbol))
       case TermRef(NoPrefix, name) =>
-        if(i.symbol is Flags.Method) Some(This(i.symbol.enclosingClass).select(i.symbol)) // workaround #342 todo: remove after fixed
+        if (i.symbol is Flags.Method) Some(This(i.symbol.enclosingClass).select(i.symbol)) // workaround #342 todo: remove after fixed
         else None
       case _ => None
     }
@@ -663,7 +663,7 @@ class DottyBackendInterface()(implicit ctx: Context) extends BackendInterface{
     def companionSymbol: Symbol = if (sym is Flags.Module) companionClass else companionModule
     def moduleClass: Symbol = toDenot(sym).moduleClass
     def enclosingClassSym: Symbol = {
-      if(this.isClass) {
+      if (this.isClass) {
         val ct = ctx.withPhase(ctx.flattenPhase.prev)
         toDenot(sym)(ct).owner.enclosingClass(ct)
       }
@@ -792,7 +792,7 @@ class DottyBackendInterface()(implicit ctx: Context) extends BackendInterface{
           t.info match {
 
             case _ =>
-              if(!t.symbol.isClass) nonClassTypeRefToBType(t.symbol)  // See comment on nonClassTypeRefToBType
+              if (!t.symbol.isClass) nonClassTypeRefToBType(t.symbol)  // See comment on nonClassTypeRefToBType
               else primitiveOrClassToBType(t.symbol) // Common reference to a type such as scala.Int or java.lang.String
           }
         case Types.ClassInfo(_, sym, _, _, _)           => primitiveOrClassToBType(sym) // We get here, for example, for genLoadModule, which invokes toTypeKind(moduleClassSymbol.info)
@@ -942,7 +942,7 @@ class DottyBackendInterface()(implicit ctx: Context) extends BackendInterface{
     def _3: Tree = field.rhs
 
     override def unapply(s: LabelDef): DottyBackendInterface.this.LabelDef.type = {
-      if(s.symbol is Flags.Label) this.field = s
+      if (s.symbol is Flags.Label) this.field = s
       else this.field = null
       this
     }
@@ -1021,11 +1021,11 @@ class DottyBackendInterface()(implicit ctx: Context) extends BackendInterface{
     def _2 = field.meth
     def _3 = {
       val t = field.tpt.tpe.typeSymbol
-      if(t.exists) t
+      if (t.exists) t
       else {
         val arity = field.meth.tpe.widenDealias.paramTypes.size - _1.size
         val returnsUnit = field.meth.tpe.widenDealias.resultType.classSymbol == UnitClass
-        if(returnsUnit)
+        if (returnsUnit)
           ctx.requiredClass(("scala.compat.java8.JProcedure" + arity).toTermName)
         else ctx.requiredClass(("scala.compat.java8.JFunction" + arity).toTermName)
       }
diff --git a/src/dotty/tools/backend/jvm/LabelDefs.scala b/src/dotty/tools/backend/jvm/LabelDefs.scala
index 769dcdc36..8f9e3bdcc 100644
--- a/src/dotty/tools/backend/jvm/LabelDefs.scala
+++ b/src/dotty/tools/backend/jvm/LabelDefs.scala
@@ -44,7 +44,7 @@ import StdNames.nme
  *
  * <label> def foo(i: Int) = {
  *   <label> def bar = 0
- *   <label> def dough(i: Int) = if(i == 0) bar else foo(i-1)
+ *   <label> def dough(i: Int) = if (i == 0) bar else foo(i-1)
  *   dough(i)
  *   }
  *
@@ -54,7 +54,7 @@ import StdNames.nme
  *
  *                                                  \
  * <label> def foo(i: Int) = dough(i)
- * <label> def dough(i: Int) = if(i == 0) bar else foo(i-1)
+ * <label> def dough(i: Int) = if (i == 0) bar else foo(i-1)
  * <label> def bar = 2
  *   foo(100)
  *
@@ -64,7 +64,7 @@ import StdNames.nme
  *  <jump foo>
  *  <label> def foo(i: Int) = dough(i)
  *  // <jump a>                           // unreachable
- *  <label> def dough(i: Int) = if(i == 0) bar else foo(i-1)
+ *  <label> def dough(i: Int) = if (i == 0) bar else foo(i-1)
  *  // <jump a>                           // unreachable
  *  <label> def bar = 2
  *  // <jump a>                           // unreachable
@@ -107,7 +107,7 @@ class LabelDefs extends MiniPhaseTransform {
               labelLevel = labelLevel + 1
               val r = Block(moveLabels(t), t)
               labelLevel = labelLevel - 1
-              if(labelLevel == 0) beingAppended.clear()
+              if (labelLevel == 0) beingAppended.clear()
               r
             case _ => if (entryPoints.nonEmpty && labelDefs.nonEmpty) super.transform(tree) else tree
           }
@@ -206,14 +206,14 @@ class LabelDefs extends MiniPhaseTransform {
         labelCalls(r.symbol) = parentLabelCalls
         parentLabelCalls = st
 
-        if(shouldMoveLabel) {
+        if (shouldMoveLabel) {
           labelDefs(r.symbol) = r
           EmptyTree
         } else r
       case t: Apply if t.symbol is Flags.Label =>
         val sym = t.symbol
         parentLabelCalls = parentLabelCalls + t
-        if(owner != sym) callCounts(sym) = callCounts(sym) + 1
+        if (owner != sym) callCounts(sym) = callCounts(sym) + 1
         super.transform(tree)
       case _ =>
         super.transform(tree)
diff --git a/src/dotty/tools/dotc/ast/tpd.scala b/src/dotty/tools/dotc/ast/tpd.scala
index 20deab372..955439413 100644
--- a/src/dotty/tools/dotc/ast/tpd.scala
+++ b/src/dotty/tools/dotc/ast/tpd.scala
@@ -776,7 +776,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       } else args
     }
 
-    val callArgs: List[Tree] = if(args.isEmpty) Nil else {
+    val callArgs: List[Tree] = if (args.isEmpty) Nil else {
       val expectedType = selected.widen.paramTypess.head.last
       val lastParam = args.last
       adaptLastArg(lastParam, expectedType)
diff --git a/src/dotty/tools/dotc/core/Symbols.scala b/src/dotty/tools/dotc/core/Symbols.scala
index e573de664..dab84bb5f 100644
--- a/src/dotty/tools/dotc/core/Symbols.scala
+++ b/src/dotty/tools/dotc/core/Symbols.scala
@@ -162,7 +162,7 @@ trait Symbols { this: Context =>
         privateWithin, coord, assocFile)
 
   def synthesizeCompanionMethod(name: Name, target: SymDenotation, owner: SymDenotation)(implicit ctx: Context) =
-    if(owner.exists && target.exists && !owner.isAbsent && !target.isAbsent) {
+    if (owner.exists && target.exists && !owner.isAbsent && !target.isAbsent) {
       val existing = owner.unforcedDecls.lookup(name)
 
       existing.orElse{
diff --git a/src/dotty/tools/dotc/core/TypeErasure.scala b/src/dotty/tools/dotc/core/TypeErasure.scala
index a45e29287..20cf816c2 100644
--- a/src/dotty/tools/dotc/core/TypeErasure.scala
+++ b/src/dotty/tools/dotc/core/TypeErasure.scala
@@ -95,7 +95,7 @@ object TypeErasure {
   def erasure(tp: Type)(implicit ctx: Context): Type = scalaErasureFn(tp)(erasureCtx)
   def semiErasure(tp: Type)(implicit ctx: Context): Type = semiErasureFn(tp)(erasureCtx)
   def sigName(tp: Type, isJava: Boolean)(implicit ctx: Context): TypeName = {
-    val seqClass = if(isJava) defn.ArrayClass else defn.SeqClass
+    val seqClass = if (isJava) defn.ArrayClass else defn.SeqClass
     val normTp =
       if (tp.isRepeatedParam) tp.translateParameterized(defn.RepeatedParamClass, seqClass)
       else tp
diff --git a/src/dotty/tools/dotc/core/Types.scala b/src/dotty/tools/dotc/core/Types.scala
index 802a4e406..e6235695e 100644
--- a/src/dotty/tools/dotc/core/Types.scala
+++ b/src/dotty/tools/dotc/core/Types.scala
@@ -76,7 +76,7 @@ object Types {
 
     val uniqId = {
       nextId = nextId + 1
-//      if(nextId == 19555)
+//      if (nextId == 19555)
 //        println("foo")
       nextId
     }
diff --git a/src/dotty/tools/dotc/core/pickling/ClassfileParser.scala b/src/dotty/tools/dotc/core/pickling/ClassfileParser.scala
index a358fc2b0..478ee0dd7 100644
--- a/src/dotty/tools/dotc/core/pickling/ClassfileParser.scala
+++ b/src/dotty/tools/dotc/core/pickling/ClassfileParser.scala
@@ -92,7 +92,7 @@ class ClassfileParser(
       if (c != classRoot.symbol) mismatchError(c)
     }
 
-    if(classRoot.symbol.id == 4812) {
+    if (classRoot.symbol.id == 4812) {
       println("bar")
     }
 
diff --git a/src/dotty/tools/dotc/parsing/JavaParsers.scala b/src/dotty/tools/dotc/parsing/JavaParsers.scala
index 4f3d20f45..297f3c0f9 100644
--- a/src/dotty/tools/dotc/parsing/JavaParsers.scala
+++ b/src/dotty/tools/dotc/parsing/JavaParsers.scala
@@ -121,11 +121,11 @@ object JavaParsers {
         case nil => (EmptyTree, nil)
       }
       var (constr1, stats1) = pullOutFirstConstr(stats)
-      if(constr1 == EmptyTree) constr1 = makeConstructor(List(), tparams)
+      if (constr1 == EmptyTree) constr1 = makeConstructor(List(), tparams)
       // A dummy first constructor is needed for Java classes so that the real constructors see the
       // import of the companion object. The constructor has parameter of type Unit so no Java code
       // can call it.
-      if(needsDummyConstr) {
+      if (needsDummyConstr) {
         stats1 = constr1 :: stats1
         constr1 = makeConstructor(List(scalaDot(tpnme.Unit)), tparams, Flags.JavaDefined | Flags.PrivateLocal)
       }
@@ -579,9 +579,9 @@ object JavaParsers {
     def varDecl(pos: Position, mods: Modifiers, tpt: Tree, name: TermName): ValDef = {
       val tpt1 = optArrayBrackets(tpt)
       if (in.token == EQUALS && !(mods is Flags.Param)) skipTo(COMMA, SEMI)
-      val mods1 = if(mods is Flags.Final) mods else mods | Flags.Mutable
+      val mods1 = if (mods is Flags.Final) mods else mods | Flags.Mutable
       atPos(pos) {
-        ValDef(name, tpt1, if(mods is Flags.Param) EmptyTree else unimplementedExpr).withMods(mods1)
+        ValDef(name, tpt1, if (mods is Flags.Param) EmptyTree else unimplementedExpr).withMods(mods1)
       }
     }
 
diff --git a/src/dotty/tools/dotc/parsing/Utility.scala b/src/dotty/tools/dotc/parsing/Utility.scala
index 83a61b47e..f522492f8 100644
--- a/src/dotty/tools/dotc/parsing/Utility.scala
+++ b/src/dotty/tools/dotc/parsing/Utility.scala
@@ -69,7 +69,7 @@ object Utility {
       else sb append c
     }
 
-    if(!sb.isEmpty) // flush buffer
+    if (!sb.isEmpty) // flush buffer
       nb += text(sb.toString())
 
     nb.toList
diff --git a/src/dotty/tools/dotc/transform/Erasure.scala b/src/dotty/tools/dotc/transform/Erasure.scala
index ab124402a..640d5f13e 100644
--- a/src/dotty/tools/dotc/transform/Erasure.scala
+++ b/src/dotty/tools/dotc/transform/Erasure.scala
@@ -412,7 +412,7 @@ object Erasure extends TypeTestsCasts{
 
     private def adaptProto(tree: untpd.Tree, pt: Type)(implicit ctx: Context) = {
       if (pt.isValueType) pt else {
-        if(tree.typeOpt.derivesFrom(ctx.definitions.UnitClass))
+        if (tree.typeOpt.derivesFrom(ctx.definitions.UnitClass))
           tree.typeOpt
         else erasure(tree.typeOpt)
       }
diff --git a/src/dotty/tools/dotc/transform/FullParameterization.scala b/src/dotty/tools/dotc/transform/FullParameterization.scala
index 0b6486225..acfeda48e 100644
--- a/src/dotty/tools/dotc/transform/FullParameterization.scala
+++ b/src/dotty/tools/dotc/transform/FullParameterization.scala
@@ -91,7 +91,7 @@ trait FullParameterization {
       case info: ExprType => (0, info.resultType)
       case _ => (0, info)
     }
-    val ctparams = if(abstractOverClass) clazz.typeParams else Nil
+    val ctparams = if (abstractOverClass) clazz.typeParams else Nil
     val ctnames = ctparams.map(_.name.unexpandedName)
 
     /** The method result type */
diff --git a/src/dotty/tools/dotc/transform/LazyVals.scala b/src/dotty/tools/dotc/transform/LazyVals.scala
index 87644d2f9..a28102d7b 100644
--- a/src/dotty/tools/dotc/transform/LazyVals.scala
+++ b/src/dotty/tools/dotc/transform/LazyVals.scala
@@ -27,7 +27,7 @@ class LazyVals extends MiniPhaseTransform with SymTransformer {
 
 
   def transformSym(d: SymDenotation)(implicit ctx: Context): SymDenotation = {
-    if(d is(Flags.Lazy, butNot = Flags.ModuleVal | Flags.Method)) {
+    if (d is(Flags.Lazy, butNot = Flags.ModuleVal | Flags.Method)) {
       // Method flag is set on lazy vals coming from Unpickler. They are already methods and shouldn't be transformed twice
       d.copySymDenotation(
         initFlags = d.flags | Flags.Method,
@@ -301,7 +301,7 @@ class LazyVals extends MiniPhaseTransform with SymTransformer {
             info.ord += 1
             ord = info.ord % flagsPerLong
             val id = info.ord / flagsPerLong
-            if(ord != 0) { // there are unused bits in already existing flag
+            if (ord != 0) { // there are unused bits in already existing flag
               offsetSymbol = companion.moduleClass.info.decl((StdNames.nme.LAZY_FIELD_OFFSET + id.toString).toTermName)
                 .suchThat(sym => (sym is Flags.Synthetic) && sym.isTerm)
                  .symbol.asTerm
@@ -335,7 +335,7 @@ class LazyVals extends MiniPhaseTransform with SymTransformer {
         val cas = Select(ref(helperModule), RLazyVals.Names.cas.toTermName)
 
         val accessor = mkThreadSafeDef(x.symbol.asTerm, claz, ord, containerSymbol, x.rhs, tpe, offset, getFlag, state, cas, setFlag, wait)
-        if(flag eq EmptyTree)
+        if (flag eq EmptyTree)
           Thicket(List(containerTree, accessor))
         else Thicket(List(containerTree, flag, accessor))
     }
diff --git a/src/dotty/tools/dotc/transform/PatternMatcher.scala b/src/dotty/tools/dotc/transform/PatternMatcher.scala
index 3e5402eb4..0a019e1c5 100644
--- a/src/dotty/tools/dotc/transform/PatternMatcher.scala
+++ b/src/dotty/tools/dotc/transform/PatternMatcher.scala
@@ -179,7 +179,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {thisTrans
     override def codegen: AbsCodegen = optimizedCodegen
 
     // when we know we're targetting Option, do some inlining the optimizer won't do
-    // for example, `o.flatMap(f)` becomes `if(o == None) None else f(o.get)`, similarly for orElse and guard
+    // for example, `o.flatMap(f)` becomes `if (o == None) None else f(o.get)`, similarly for orElse and guard
     //   this is a special instance of the advanced inlining optimization that takes a method call on
     //   an object of a type that only has two concrete subclasses, and inlines both bodies, guarded by an if to distinguish the two cases
     object optimizedCodegen extends CommonCodegen {
@@ -407,11 +407,11 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {thisTrans
 
       val nextBinder: Symbol
       lazy val introducedRebindings = /*
-        if(nextBinder ne prevBinder) Rebindings(prevBinder, nextBinder)
+        if (nextBinder ne prevBinder) Rebindings(prevBinder, nextBinder)
         else */ NoRebindings
 
       def chainBefore(next: Tree)(casegen: Casegen): Tree =
-        if(prevBinder ne nextBinder) // happens when typeTest is known to succeed
+        if (prevBinder ne nextBinder) // happens when typeTest is known to succeed
           /*atPos(pos)(*/casegen.flatMapCond(cond, res, nextBinder, next)//)
         else casegen.flatMapGuard(cond, next)
     }
@@ -477,7 +477,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {thisTrans
               def refTpeWiden = ref.tpe.widen
               def bindInfoWiden = bind.info.widen
               def loc = bind.showFullName
-              if(!(ref.tpe <:< bind.info.widen)) {
+              if (!(ref.tpe <:< bind.info.widen)) {
                 ctx.debuglog(s"here ${bind.showFullName} expected: ${bindInfoWiden.show} got: ${refTpeWiden.show}")
               }
               val refCasted = ref.ensureConforms(bind.info)
@@ -954,7 +954,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {thisTrans
     object WildcardPattern {
       def unapply(pat: Tree): Boolean = pat match {
         case Bind(nme.WILDCARD, WildcardPattern()) => true // don't skip when binding an interesting symbol!
-        case t if(tpd.isWildcardArg(t))            => true
+        case t if (tpd.isWildcardArg(t))            => true
         case x: Ident                              => isVarPattern(x)
         case Alternative(ps)                       => ps forall unapply
         case EmptyTree                             => true
@@ -1424,7 +1424,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {thisTrans
           else genDrop(binder, expectedLength)
           )
         // this error-condition has already been checked by checkStarPatOK:
-        //   if(isSeq) assert(firstIndexingBinder + nbIndexingIndices + (if(lastIsStar) 1 else 0) == totalArity, "(resultInMonad, ts, subPatTypes, subPats)= " +(resultInMonad, ts, subPatTypes, subPats))
+        //   if (isSeq) assert(firstIndexingBinder + nbIndexingIndices + (if (lastIsStar) 1 else 0) == totalArity, "(resultInMonad, ts, subPatTypes, subPats)= " +(resultInMonad, ts, subPatTypes, subPats))
 
         // [1] there are `firstIndexingBinder` non-seq tuple elements preceding the Seq
         // [2] then we have to index the binder that represents the sequence for the remaining subpatterns, except for...
@@ -1440,7 +1440,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {thisTrans
       // require (nbSubPats > 0 && (!lastIsStar || isSeq))
       protected def subPatRefs(binder: Symbol): List[Tree] = {
         val refs = if (totalArity > 0 && isSeq) subPatRefsSeq(binder)
-        else if(defn.isProductSubType(binder.info)) productElemsToN(binder, totalArity)
+        else if (defn.isProductSubType(binder.info)) productElemsToN(binder, totalArity)
         else ref(binder):: Nil
         val refsSymbols = refs.map(_.symbol)  // just for debugging
         refs
@@ -1551,7 +1551,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {thisTrans
       // the trees that select the subpatterns on the extractor's result, referenced by `binder`
       // require (totalArity > 0 && (!lastIsStar || isSeq))
       protected def subPatRefs(binder: Symbol, subpatBinders: List[Symbol], binderTypeTested: Type): List[Tree] = {
-        if(aligner.isSingle && aligner.extractor.prodArity == 1 && defn.isTupleType(binder.info)) {
+        if (aligner.isSingle && aligner.extractor.prodArity == 1 && defn.isTupleType(binder.info)) {
           // special case for extractor
           // comparing with scalac additional assertions added
           val subpw = subpatBinders.head.info.widen
@@ -1815,8 +1815,8 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {thisTrans
         //println(s"${_id}unapplyArgs(${result.widen}")
         val expanded:List[Type] = /*(
           if (result =:= defn.BooleanType) Nil
-          else if(defn.isProductSubType(result)) productSelectorTypes(result)
-          else if(result.classSymbol is Flags.CaseClass) result.decls.filter(x => x.is(Flags.CaseAccessor) && x.is(Flags.Method)).map(_.info).toList
+          else if (defn.isProductSubType(result)) productSelectorTypes(result)
+          else if (result.classSymbol is Flags.CaseClass) result.decls.filter(x => x.is(Flags.CaseAccessor) && x.is(Flags.Method)).map(_.info).toList
           else result.select(nme.get) :: Nil
           )*/
           if ((extractorMemberType(resultType, nme.isDefined) isRef defn.BooleanClass) && resultOfGet.exists)
diff --git a/src/dotty/tools/dotc/transform/SuperAccessors.scala b/src/dotty/tools/dotc/transform/SuperAccessors.scala
index 36f0acc83..8857b6921 100644
--- a/src/dotty/tools/dotc/transform/SuperAccessors.scala
+++ b/src/dotty/tools/dotc/transform/SuperAccessors.scala
@@ -554,7 +554,7 @@ class SuperAccessors extends MacroTransform with IdentityDenotTransformer { this
         assert(referencingClass.isClass, referencingClass)
         referencingClass
       }
-      else if(referencingClass.owner.enclosingClass.exists)
+      else if (referencingClass.owner.enclosingClass.exists)
         hostForAccessorOf(sym, referencingClass.owner.enclosingClass.asClass)
       else
         referencingClass
diff --git a/src/dotty/tools/dotc/transform/TailRec.scala b/src/dotty/tools/dotc/transform/TailRec.scala
index 2fd0c439c..09b4c735b 100644
--- a/src/dotty/tools/dotc/transform/TailRec.scala
+++ b/src/dotty/tools/dotc/transform/TailRec.scala
@@ -210,7 +210,7 @@ class TailRec extends MiniPhaseTransform with DenotTransformer with FullParamete
           val reciever = noTailTransform(recv)
 
           val callTargs: List[tpd.Tree] =
-            if(abstractOverClass) {
+            if (abstractOverClass) {
               val classTypeArgs = recv.tpe.baseTypeWithArgs(enclosingClass).argInfos
               targs ::: classTypeArgs.map(x => ref(x.typeSymbol))
             } else targs
diff --git a/src/dotty/tools/dotc/transform/TraitConstructors.scala b/src/dotty/tools/dotc/transform/TraitConstructors.scala
index 8c92f1f7b..a98f52ca4 100644
--- a/src/dotty/tools/dotc/transform/TraitConstructors.scala
+++ b/src/dotty/tools/dotc/transform/TraitConstructors.scala
@@ -22,7 +22,7 @@ class TraitConstructors extends MiniPhaseTransform with SymTransformer {
   override def treeTransformPhase: Phase = this.phase
 
   def transformSym(sym: SymDenotation)(implicit ctx: Context): SymDenotation = {
-    if(sym.isPrimaryConstructor && (sym.owner is Flags.Trait))
+    if (sym.isPrimaryConstructor && (sym.owner is Flags.Trait))
       sym.copySymDenotation(name = nme.INITIALIZER_PREFIX ++ sym.owner.fullName)
     else sym
   }
diff --git a/src/dotty/tools/dotc/transform/TreeChecker.scala b/src/dotty/tools/dotc/transform/TreeChecker.scala
index af5a9a1f2..43e1ce8a6 100644
--- a/src/dotty/tools/dotc/transform/TreeChecker.scala
+++ b/src/dotty/tools/dotc/transform/TreeChecker.scala
@@ -116,7 +116,7 @@ class TreeChecker extends Phase with SymTransformer {
         val sym = tree.symbol
         everDefinedSyms.get(sym) match {
           case Some(t)  =>
-            if(t ne tree)
+            if (t ne tree)
               ctx.warning(i"symbol ${sym.fullName} is defined at least twice in different parts of AST")
             // should become an error
           case None =>
@@ -124,7 +124,7 @@ class TreeChecker extends Phase with SymTransformer {
         }
         assert(!nowDefinedSyms.contains(sym), i"doubly defined symbol: ${sym.fullName} in $tree")
 
-        if(ctx.settings.YcheckMods.value) {
+        if (ctx.settings.YcheckMods.value) {
           tree match {
             case t: MemberDef =>
               if (t.name ne sym.name) ctx.warning(s"symbol ${sym.fullName} name doesn't correspond to AST: ${t}")
diff --git a/src/dotty/tools/dotc/transform/TreeTransform.scala b/src/dotty/tools/dotc/transform/TreeTransform.scala
index ce3e3ce63..3bd005991 100644
--- a/src/dotty/tools/dotc/transform/TreeTransform.scala
+++ b/src/dotty/tools/dotc/transform/TreeTransform.scala
@@ -186,7 +186,7 @@ object TreeTransforms {
         case ref: SymDenotation =>
           val annotTrees = ref.annotations.map(_.tree)
           val annotTrees1 = annotTrees.mapConserve(annotationTransformer.macroTransform)
-          val annots1 = if(annotTrees eq annotTrees1) ref.annotations else annotTrees1.map(new ConcreteAnnotation(_))
+          val annots1 = if (annotTrees eq annotTrees1) ref.annotations else annotTrees1.map(new ConcreteAnnotation(_))
           if ((info1 eq ref.info) && (annots1 eq ref.annotations)) ref
           else ref.copySymDenotation(info = info1, annotations = annots1)
         case _ => if (info1 eq ref.info) ref else ref.derivedSingleDenotation(ref.symbol, info1)
diff --git a/src/dotty/tools/dotc/typer/FrontEnd.scala b/src/dotty/tools/dotc/typer/FrontEnd.scala
index b3cc23ba4..bb313501d 100644
--- a/src/dotty/tools/dotc/typer/FrontEnd.scala
+++ b/src/dotty/tools/dotc/typer/FrontEnd.scala
@@ -25,7 +25,7 @@ class FrontEnd extends Phase {
   def parse(implicit ctx: Context) = monitor("parsing") {
     val unit = ctx.compilationUnit
     unit.untpdTree =
-      if(unit.isJava) new JavaParser(unit.source).parse()
+      if (unit.isJava) new JavaParser(unit.source).parse()
       else new Parser(unit.source).parse()
     typr.println("parsed:\n" + unit.untpdTree.show)
   }
diff --git a/src/dotty/tools/dotc/typer/Implicits.scala b/src/dotty/tools/dotc/typer/Implicits.scala
index 2c7aaaeb1..cd3b633ac 100644
--- a/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/src/dotty/tools/dotc/typer/Implicits.scala
@@ -347,7 +347,7 @@ trait ImplicitRunInfo { self: RunInfo =>
             if (liftedTp ne tp) iscope(liftedTp, isLifted = true)
             else ofTypeImplicits(collectCompanions(tp))
           if (ctx.typerState.ephemeral) record("ephemeral cache miss: implicitScope")
-          else if(cacheResult) implicitScopeCache(tp) = result
+          else if (cacheResult) implicitScopeCache(tp) = result
           result
         }
         finally ctx.typerState.ephemeral |= savedEphemeral
diff --git a/src/dotty/tools/dotc/typer/RefChecks.scala b/src/dotty/tools/dotc/typer/RefChecks.scala
index 2783f7f31..9b14fffc0 100644
--- a/src/dotty/tools/dotc/typer/RefChecks.scala
+++ b/src/dotty/tools/dotc/typer/RefChecks.scala
@@ -1057,7 +1057,7 @@ class RefChecks extends MiniPhase with SymTransformer { thisTransformer =>
                                                       // FIXME: reconcile this check with one in resetAttrs
           case _ => checkUndesiredProperties(sym, tree.pos)
         }
-        if(sym.isJavaDefined)
+        if (sym.isJavaDefined)
           sym.typeParams foreach (_.cookJavaRawInfo())
         if (!tp.isHigherKinded && !skipBounds)
           checkBounds(tree, pre, sym.owner, sym.typeParams, args)
@@ -1101,7 +1101,7 @@ class RefChecks extends MiniPhase with SymTransformer { thisTransformer =>
           }
 
         case tpt@TypeTree() =>
-          if(tpt.original != null) {
+          if (tpt.original != null) {
             tpt.original foreach {
               case dc@TypeTreeWithDeferredRefCheck() =>
                 applyRefchecksToAnnotations(dc.check()) // #2416
diff --git a/src/dotty/tools/dotc/typer/Typer.scala b/src/dotty/tools/dotc/typer/Typer.scala
index 6befe58df..a2b280c6e 100644
--- a/src/dotty/tools/dotc/typer/Typer.scala
+++ b/src/dotty/tools/dotc/typer/Typer.scala
@@ -309,7 +309,7 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
       }
     }
 
-    if(ctx.compilationUnit.isJava && tree.name.isTypeName) {
+    if (ctx.compilationUnit.isJava && tree.name.isTypeName) {
       // SI-3120 Java uses the same syntax, A.B, to express selection from the
       // value A and from the type A. We have to try both.
       tryEither(tryCtx => asSelect(tryCtx))((_,_) => asJavaSelectFromTypeTree(ctx))