Inline clazz into if/else toremove lazy

Author: nicolasstucki

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

@@ -101,37 +101,42 @@ class SuperAccessors(thisTransformer: DenotTransformer) {
       val Select(sup @ Super(_, mix), name) = sel
       val sym   = sel.symbol
       assert(sup.symbol.exists, s"missing symbol in $sel: ${sup.tpe}")
-      lazy val clazz = sup.symbol.asClass
 
-      if (sym.isTerm && !sym.is(Method, butNot = Accessor) && !ctx.owner.is(ParamForwarder))
+      if (sym.isTerm && !sym.is(Method, butNot = Accessor) && !ctx.owner.is(ParamForwarder)) {
         // ParamForwaders as installed ParamForwarding.scala do use super calls to vals
         ctx.error(s"super may be not be used on ${sym.underlyingSymbol}", sel.pos)
-      else if (isDisallowed(sym))
+        sel
+      } else if (isDisallowed(sym)) {
         ctx.error(s"super not allowed here: use this.${sel.name} instead", sel.pos)
-      else if (sym is Deferred) {
-        val member = sym.overridingSymbol(clazz)
-        if (!mix.name.isEmpty ||
+        sel
+      } else {
+        val clazz = sup.symbol.asClass
+        if (sym is Deferred) {
+          val member = sym.overridingSymbol(clazz)
+          if (!mix.name.isEmpty ||
             !member.exists ||
             !((member is AbsOverride) && member.isIncompleteIn(clazz)))
-          ctx.error(
+            ctx.error(
               i"${sym.showLocated} is accessed from super. It may not be abstract unless it is overridden by a member declared `abstract' and `override'",
               sel.pos)
-        else ctx.log(i"ok super $sel ${sym.showLocated} $member $clazz ${member.isIncompleteIn(clazz)}")
-      }
-      else if (mix.name.isEmpty && !(sym.owner is Trait))
+          else ctx.log(i"ok super $sel ${sym.showLocated} $member $clazz ${member.isIncompleteIn(clazz)}")
+        }
+        else if (mix.name.isEmpty && !(sym.owner is Trait))
         // SI-4989 Check if an intermediate class between `clazz` and `sym.owner` redeclares the method as abstract.
-        for (intermediateClass <- clazz.info.baseClasses.tail.takeWhile(_ != sym.owner)) {
-          val overriding = sym.overridingSymbol(intermediateClass)
-          if ((overriding is (Deferred, butNot = AbsOverride)) && !(overriding.owner is Trait))
-            ctx.error(
+          for (intermediateClass <- clazz.info.baseClasses.tail.takeWhile(_ != sym.owner)) {
+            val overriding = sym.overridingSymbol(intermediateClass)
+            if ((overriding is(Deferred, butNot = AbsOverride)) && !(overriding.owner is Trait))
+              ctx.error(
                 s"${sym.showLocated} cannot be directly accessed from ${clazz} because ${overriding.owner} redeclares it as abstract",
                 sel.pos)
 
-        }
-      if (name.isTermName && mix.name.isEmpty &&
-          ((clazz is Trait) || clazz != ctx.owner.enclosingClass || !validCurrentClass))
-        superAccessorCall(sel)(ctx.withPhase(thisTransformer.next))
-      else sel
+          }
+
+        if (name.isTermName && mix.name.isEmpty &&
+            ((clazz is Trait) || clazz != ctx.owner.enclosingClass || !validCurrentClass))
+          superAccessorCall(sel)(ctx.withPhase(thisTransformer.next))
+        else sel
+      }
     }
 
     /** Disallow some super.XX calls targeting Any methods which would