Minor spacing & formating

Author: OlivierBlanvillain

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

@@ -106,22 +106,23 @@ object desugar {
   def valDef(vdef: ValDef)(implicit ctx: Context): Tree = {
     val ValDef(name, tpt, rhs) = vdef
     val mods = vdef.mods
-    def setterNeeded =
+    val setterNeeded =
       (mods is Mutable) && ctx.owner.isClass && (!(mods is PrivateLocal) || (ctx.owner is Trait))
     if (setterNeeded) {
-      // todo: copy of vdef as getter needed?
-      // val getter = ValDef(mods, name, tpt, rhs) withPos vdef.pos ?
+      // TODO: copy of vdef as getter needed?
+      // val getter = ValDef(mods, name, tpt, rhs) withPos vdef.pos?
       // right now vdef maps via expandedTree to a thicket which concerns itself.
       // I don't see a problem with that but if there is one we can avoid it by making a copy here.
       val setterParam = makeSyntheticParameter(tpt = (new SetterParamTree).watching(vdef))
+      // The rhs gets filled in later, when field is generated and getter has parameters (see Memoize miniphase)
       val setterRhs = if (vdef.rhs.isEmpty) EmptyTree else unitLiteral
       val setter = cpy.DefDef(vdef)(
-        name = name.setterName,
-        tparams = Nil,
+        name     = name.setterName,
+        tparams  = Nil,
         vparamss = (setterParam :: Nil) :: Nil,
-        tpt = TypeTree(defn.UnitType),
-        rhs = setterRhs
-      ).withMods((mods | Accessor) &~ CaseAccessor) // rhs gets filled in later, when field is generated and getter has parameters
+        tpt      = TypeTree(defn.UnitType),
+        rhs      = setterRhs
+      ).withMods((mods | Accessor) &~ CaseAccessor)
       Thicket(vdef, setter)
     }
     else vdef

compiler/src/dotty/tools/dotc/transform/Memoize.scala

@@ -50,7 +50,7 @@ import Decorators._
         if !ddef.symbol.is(Deferred) &&
            !ddef.symbol.isConstructor && // constructors bodies are added later at phase Constructors
            ddef.rhs == EmptyTree =>
-          errorLackImplementation(ddef)
+        errorLackImplementation(ddef)
       case tdef: TypeDef
         if tdef.symbol.isClass && !tdef.symbol.is(Deferred) && tdef.rhs == EmptyTree =>
         errorLackImplementation(tdef)
@@ -76,12 +76,12 @@ import Decorators._
 
       ctx.newSymbol(
         owner = ctx.owner,
-        name = sym.name.asTermName.fieldName,
+        name  = sym.name.asTermName.fieldName,
         flags = Private | (if (sym is Stable) EmptyFlags else Mutable),
-        info = fieldType,
-        coord = tree.pos)
-        .withAnnotationsCarrying(sym, defn.FieldMetaAnnot)
-        .enteredAfter(thisTransform)
+        info  = fieldType,
+        coord = tree.pos
+      ).withAnnotationsCarrying(sym, defn.FieldMetaAnnot)
+       .enteredAfter(thisTransform)
     }
 
     /** Can be used to filter annotations on getters and setters; not used yet */
@@ -93,7 +93,7 @@ import Decorators._
 
     lazy val field = sym.field.orElse(newField).asTerm
 
-    def adaptToField(tree: Tree) =
+    def adaptToField(tree: Tree): Tree =
       if (tree.isEmpty) tree else tree.ensureConforms(field.info.widen)
 
     val NoFieldNeeded = Lazy | Deferred | JavaDefined | (if (ctx.settings.YnoInline.value) EmptyFlags else Inline)
@@ -127,8 +127,8 @@ import Decorators._
         val getterDef = cpy.DefDef(tree)(rhs = getterRhs)
         Thicket(fieldDef, getterDef)
       } else if (sym.isSetter) {
-        if (!sym.is(ParamAccessor)) { val Literal(Constant(())) = tree.rhs } // this is intended as an assertion
-        field.setFlag(Mutable) // necessary for vals mixed in from Scala2 traits
+        if (!sym.is(ParamAccessor)) { val Literal(Constant(())) = tree.rhs } // This is intended as an assertion
+        field.setFlag(Mutable) // Necessary for vals mixed in from Scala2 traits
         if (isErasableBottomField(tree.vparamss.head.head.tpt.tpe.classSymbol)) tree
         else {
           val initializer = Assign(ref(field), adaptToField(ref(tree.vparamss.head.head.symbol)))