Avoid overhead of dead code checking unless -Ywarn-dead-code is set

Initialization of the member module, `checkDead`, would create an
empty mutable Stack, on each nested typer, which is wasteful.

This commit creates two implementation of `CheckDead`. The no-op
case is a shared singleton object.

Author: retronym

src/compiler/scala/tools/nsc/typechecker/TypeDiagnostics.scala

@@ -676,40 +676,6 @@ trait TypeDiagnostics {
         }
       }
     }
-
-    object checkDead {
-      private val exprStack: mutable.Stack[Symbol] = mutable.Stack(NoSymbol)
-      // The method being applied to `tree` when `apply` is called.
-      private def expr = exprStack.top
-
-      private def exprOK =
-        (expr != Object_synchronized) &&
-        !(expr.isLabel && treeInfo.isSynthCaseSymbol(expr)) // it's okay to jump to matchEnd (or another case) with an argument of type nothing
-
-      private def treeOK(tree: Tree) = {
-        val isLabelDef = tree match { case _: LabelDef => true; case _ => false}
-        tree.tpe != null && tree.tpe.typeSymbol == NothingClass && !isLabelDef
-      }
-
-      @inline def updateExpr[A](fn: Tree)(f: => A) = {
-        if (fn.symbol != null && fn.symbol.isMethod && !fn.symbol.isConstructor) {
-          exprStack push fn.symbol
-          try f finally exprStack.pop()
-        } else f
-      }
-      def apply(tree: Tree): Tree = {
-        // Error suppression (in context.warning) would squash some of these warnings.
-        // It is presumed if you are using a -Y option you would really like to hear
-        // the warnings you've requested; thus, use reporter.warning.
-        if (settings.warnDeadCode && context.unit.exists && treeOK(tree) && exprOK)
-          reporter.warning(tree.pos, "dead code following this construct")
-        tree
-      }
-
-      // The checkDead call from typedArg is more selective.
-      def inMode(mode: Mode, tree: Tree): Tree = if (mode.typingMonoExprByValue) apply(tree) else tree
-    }
-
     private def symWasOverloaded(sym: Symbol) = sym.owner.isClass && sym.owner.info.member(sym.name).isOverloaded
     private def cyclicAdjective(sym: Symbol)  = if (symWasOverloaded(sym)) "overloaded" else "recursive"
 

src/compiler/scala/tools/nsc/typechecker/Typers.scala

@@ -109,6 +109,60 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
   private final val InterpolatorCodeRegex  = """\$\{\s*(.*?)\s*\}""".r
   private final val InterpolatorIdentRegex = """\$[$\w]+""".r // note that \w doesn't include $
 
+  abstract sealed class CheckDead {
+    def apply(tree: Tree): Tree
+    @inline final def updateExpr[A](fn: Tree)(f: => A): A = {
+      if (push(fn)) {
+        try f finally pop()
+      } else f
+    }
+    def push(fn: Tree): Boolean
+    def pop(): Unit
+    def inMode(mode: Mode, tree: Tree): Tree
+  }
+  object NoOpCheckDead extends CheckDead {
+    def apply(tree: Tree): Tree = tree
+    def push(fn: Tree): Boolean = false
+    def pop(): Unit = ()
+    def inMode(mode: Mode, tree: Tree): Tree = tree
+  }
+  class CheckingCheckDead() extends CheckDead {
+    private val exprStack: mutable.Stack[Symbol] = mutable.Stack(NoSymbol)
+    // The method being applied to `tree` when `apply` is called.
+    private def expr = exprStack.top
+
+    private def exprOK =
+      (expr != Object_synchronized) &&
+      !(expr.isLabel && treeInfo.isSynthCaseSymbol(expr)) // it's okay to jump to matchEnd (or another case) with an argument of type nothing
+
+    private def treeOK(tree: Tree) = {
+      val isLabelDef = tree match { case _: LabelDef => true; case _ => false}
+      tree.tpe != null && tree.tpe.typeSymbol == NothingClass && !isLabelDef
+    }
+
+    def push(fn: Tree): Boolean = {
+      if (fn.symbol != null && fn.symbol.isMethod && !fn.symbol.isConstructor) {
+        exprStack push fn.symbol
+        true
+      } else false
+    }
+    def pop(): Unit =
+      exprStack.pop()
+
+    def apply(tree: Tree): Tree = {
+      // Error suppression (in context.warning) would squash some of these warnings.
+      // It is presumed if you are using a -Y option you would really like to hear
+      // the warnings you've requested; thus, use reporter.warning.
+      if (treeOK(tree) && exprOK)
+        reporter.warning(tree.pos, "dead code following this construct")
+      tree
+    }
+
+    // The checkDead call from typedArg is more selective.
+    def inMode(mode: Mode, tree: Tree): Tree = if (mode.typingMonoExprByValue) apply(tree) else tree
+  }
+
+
   abstract class Typer(context0: Context) extends TyperDiagnostics with Adaptation with Tag with PatternTyper with TyperContextErrors {
     import context0.unit
     import typeDebug.ptTree
@@ -254,6 +308,14 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
     var context = context0
     def context1 = context
 
+    private var _checkDead: CheckDead = _
+    private def checkDead: CheckDead = {
+      if (_checkDead == null) {
+        _checkDead = if (settings.warnDeadCode.value && context != null && context.unit.exists) new CheckingCheckDead() else NoOpCheckDead
+      }
+      _checkDead
+    }
+
     // for use with silent type checking to when we can't have results with undetermined type params
     // note that this captures the context var
     val isMonoContext = (_: Any) => context.undetparams.isEmpty