Refactor flag juggling. Review feedback from Jason.

Sometimes booleans and a little duplication go a long way.

5 files changed, 54 insertions, 49 deletions

diff --git a/src/compiler/scala/reflect/macros/contexts/Typers.scala b/src/compiler/scala/reflect/macros/contexts/Typers.scala
index 28c1e3ddb3..baf066c7d9 100644
--- a/src/compiler/scala/reflect/macros/contexts/Typers.scala
+++ b/src/compiler/scala/reflect/macros/contexts/Typers.scala
@@ -18,22 +18,25 @@ trait Typers {
    * @see [[scala.tools.reflect.ToolBox.typeCheck]]
    */
   def typecheck(tree: Tree, mode: TypecheckMode = TERMmode, pt: Type = universe.WildcardType, silent: Boolean = false, withImplicitViewsDisabled: Boolean = false, withMacrosDisabled: Boolean = false): Tree = {
-    macroLogVerbose("typechecking %s with expected type %s, implicit views = %s, macros = %s".format(tree, pt, !withImplicitViewsDisabled, !withMacrosDisabled))
-    val context = callsiteTyper.context
-    val withImplicitFlag = if (!withImplicitViewsDisabled) (context.withImplicitsEnabled[Tree] _) else (context.withImplicitsDisabled[Tree] _)
-    val withMacroFlag = if (!withMacrosDisabled) (context.withMacrosEnabled[Tree] _) else (context.withMacrosDisabled[Tree] _)
-    def withContext(tree: => Tree) = withImplicitFlag(withMacroFlag(tree))
-    def withWrapping(tree: Tree)(op: Tree => Tree) = if (mode == TERMmode) universe.wrappingIntoTerm(tree)(op) else op(tree)
-    def typecheckInternal(tree: Tree) = callsiteTyper.silent(_.typed(universe.duplicateAndKeepPositions(tree), mode, pt), reportAmbiguousErrors = false)
-    withWrapping(tree)(wrappedTree => withContext(typecheckInternal(wrappedTree) match {
-      case universe.analyzer.SilentResultValue(result) =>
-        macroLogVerbose(result)
-        result
-      case error @ universe.analyzer.SilentTypeError(_) =>
-        macroLogVerbose(error.err.errMsg)
-        if (!silent) throw new TypecheckException(error.err.errPos, error.err.errMsg)
-        universe.EmptyTree
-    }))
+    macroLogVerbose(s"typechecking $tree with expected type $pt, implicit views = ${!withImplicitViewsDisabled}, macros = ${!withMacrosDisabled}")
+    import callsiteTyper.context
+    def doTypecheck(wrapped: Tree): Tree =
+      context.withImplicits(enabled = !withImplicitViewsDisabled) {
+        context.withMacros(enabled = !withMacrosDisabled) {
+          callsiteTyper.silent(_.typed(universe.duplicateAndKeepPositions(wrapped), mode, pt), reportAmbiguousErrors = false) match {
+            case universe.analyzer.SilentResultValue(result) =>
+              macroLogVerbose(result)
+              result
+            case error@universe.analyzer.SilentTypeError(_) =>
+              macroLogVerbose(error.err.errMsg)
+              if (!silent) throw new TypecheckException(error.err.errPos, error.err.errMsg)
+              universe.EmptyTree
+          }
+        }
+      }
+
+    if (mode == TERMmode) universe.wrappingIntoTerm(tree)(doTypecheck)
+    else doTypecheck(tree)
   }
 
   def inferImplicitValue(pt: Type, silent: Boolean = true, withMacrosDisabled: Boolean = false, pos: Position = enclosingPosition): Tree = {
diff --git a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
index c5a3d605b1..bcc1ed3e64 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Contexts.scala
@@ -387,8 +387,10 @@ trait Contexts { self: Analyzer =>
     @inline final def withImplicitsEnabled[T](op: => T): T                 = withMode(enabled = ImplicitsEnabled)(op)
     @inline final def withImplicitsDisabled[T](op: => T): T                = withMode(disabled = ImplicitsEnabled | EnrichmentEnabled)(op)
     @inline final def withImplicitsDisabledAllowEnrichment[T](op: => T): T = withMode(enabled = EnrichmentEnabled, disabled = ImplicitsEnabled)(op)
+    @inline final def withImplicits[T](enabled: Boolean)(op: => T): T      = if (enabled) withImplicitsEnabled(op) else withImplicitsDisabled(op)
     @inline final def withMacrosEnabled[T](op: => T): T                    = withMode(enabled = MacrosEnabled)(op)
     @inline final def withMacrosDisabled[T](op: => T): T                   = withMode(disabled = MacrosEnabled)(op)
+    @inline final def withMacros[T](enabled: Boolean)(op: => T): T         = if (enabled) withMacrosEnabled(op) else withMacrosDisabled(op)
     @inline final def withinStarPatterns[T](op: => T): T                   = withMode(enabled = StarPatterns)(op)
     @inline final def withinSuperInit[T](op: => T): T                      = withMode(enabled = SuperInit)(op)
     @inline final def withinSecondTry[T](op: => T): T                      = withMode(enabled = SecondTry)(op)
diff --git a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
index 6412cc09f9..bee2ae8e99 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Implicits.scala
@@ -49,11 +49,11 @@ trait Implicits {
   def inferImplicitByTypeSilent(pt: Type, context: Context, pos: Position = NoPosition): SearchResult =
     inferImplicit(EmptyTree, pt, reportAmbiguous = false, isView = false, context, saveAmbiguousDivergent = false, pos)
 
-  @deprecated("Unused in scalac")
+  @deprecated("Unused in scalac", "2.12.0-M4")
   def inferImplicit(tree: Tree, pt: Type, reportAmbiguous: Boolean, isView: Boolean, context: Context): SearchResult =
     inferImplicit(tree, pt, reportAmbiguous, isView, context, saveAmbiguousDivergent = true, tree.pos)
 
-  @deprecated("Unused in scalac")
+  @deprecated("Unused in scalac", "2.12.0-M4")
   def inferImplicit(tree: Tree, pt: Type, reportAmbiguous: Boolean, isView: Boolean, context: Context, saveAmbiguousDivergent: Boolean): SearchResult =
     inferImplicit(tree, pt, reportAmbiguous, isView, context, saveAmbiguousDivergent, tree.pos)
 
@@ -111,12 +111,9 @@ trait Implicits {
   /** A friendly wrapper over inferImplicit to be used in macro contexts and toolboxes.
    */
   def inferImplicit(tree: Tree, pt: Type, isView: Boolean, context: Context, silent: Boolean, withMacrosDisabled: Boolean, pos: Position, onError: (Position, String) => Unit): Tree = {
-    val result =
-      if (withMacrosDisabled) context.withMacrosDisabled {
-        inferImplicit(tree, pt, reportAmbiguous = true, isView = isView, context, saveAmbiguousDivergent = !silent, pos)
-      } else context.withMacrosEnabled {
-        inferImplicit(tree, pt, reportAmbiguous = true, isView = isView, context, saveAmbiguousDivergent = !silent, pos)
-      }
+    val result = context.withMacros(enabled = !withMacrosDisabled) {
+      inferImplicit(tree, pt, reportAmbiguous = true, isView = isView, context, saveAmbiguousDivergent = !silent, pos)
+    }
 
     if (result.isFailure && !silent) {
       val err = context.reporter.firstError
diff --git a/src/compiler/scala/tools/nsc/typechecker/Tags.scala b/src/compiler/scala/tools/nsc/typechecker/Tags.scala
index 21fdf75d66..e29451f379 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Tags.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Tags.scala
@@ -13,9 +13,7 @@ trait Tags {
     private val runDefinitions = currentRun.runDefinitions
 
     private def resolveTag(pos: Position, taggedTp: Type, allowMaterialization: Boolean) = enteringTyper {
-      if (allowMaterialization) context.withMacrosEnabled{ inferImplicitByType(taggedTp, context, pos).tree }
-      else context.withMacrosDisabled{ inferImplicitByType(taggedTp, context, pos).tree }
-
+      context.withMacros(enabled = allowMaterialization) { inferImplicitByType(taggedTp, context, pos).tree }
     }
 
     /** Finds in scope or materializes a ClassTag.
diff --git a/src/compiler/scala/tools/reflect/ToolBoxFactory.scala b/src/compiler/scala/tools/reflect/ToolBoxFactory.scala
index ae6a9e22b6..9c4d521336 100644
--- a/src/compiler/scala/tools/reflect/ToolBoxFactory.scala
+++ b/src/compiler/scala/tools/reflect/ToolBoxFactory.scala
@@ -117,13 +117,15 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf =>
 
       def transformDuringTyper(expr: Tree, mode: scala.reflect.internal.Mode, withImplicitViewsDisabled: Boolean, withMacrosDisabled: Boolean)(transform: (analyzer.Typer, Tree) => Tree): Tree = {
         def withWrapping(tree: Tree)(op: Tree => Tree) = if (mode == TERMmode) wrappingIntoTerm(tree)(op) else op(tree)
-        withWrapping(verify(expr))(expr1 => {
+        withWrapping(verify(expr)) { expr =>
           // need to extract free terms, because otherwise you won't be able to typecheck macros against something that contains them
-          val exprAndFreeTerms = extractFreeTerms(expr1, wrapFreeTermRefs = false)
-          var expr2 = exprAndFreeTerms._1
-          val freeTerms = exprAndFreeTerms._2
-          val dummies = freeTerms.map{ case (freeTerm, name) => ValDef(NoMods, name, TypeTree(freeTerm.info), Select(Ident(PredefModule), newTermName("$qmark$qmark$qmark"))) }.toList
-          expr2 = Block(dummies, expr2)
+          val (extracted, freeTerms) = extractFreeTerms(expr, wrapFreeTermRefs = false)
+          val exprBound = {
+            val binders = freeTerms.toList.map { case (freeTerm, name) =>
+              ValDef(NoMods, name, TypeTree(freeTerm.info), Select(Ident(PredefModule), newTermName("$qmark$qmark$qmark")))
+            }
+            Block(binders, extracted)
+          }
 
           // !!! Why is this is in the empty package? If it's only to make
           // it inaccessible then please put it somewhere designed for that
@@ -131,26 +133,29 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf =>
           // [Eugene] how can we implement that?
           val ownerClass       = rootMirror.EmptyPackageClass.newClassSymbol(newTypeName("<expression-owner>"))
           build.setInfo(ownerClass, ClassInfoType(List(ObjectTpe), newScope, ownerClass))
-          val owner            = ownerClass.newLocalDummy(expr2.pos)
-          val currentTyper     = analyzer.newTyper(analyzer.rootContext(NoCompilationUnit, EmptyTree).make(expr2, owner))
-          val withImplicitFlag = if (!withImplicitViewsDisabled) (currentTyper.context.withImplicitsEnabled[Tree] _) else (currentTyper.context.withImplicitsDisabled[Tree] _)
-          val withMacroFlag    = if (!withMacrosDisabled) (currentTyper.context.withMacrosEnabled[Tree] _) else (currentTyper.context.withMacrosDisabled[Tree] _)
-          def withContext      (tree: => Tree) = withImplicitFlag(withMacroFlag(tree))
+          val owner            = ownerClass.newLocalDummy(exprBound.pos)
+          val currentTyper     = analyzer.newTyper(analyzer.rootContext(NoCompilationUnit, EmptyTree).make(exprBound, owner))
+          import currentTyper.{context => currCtx}
 
           val run = new Run
           run.symSource(ownerClass) = NoAbstractFile // need to set file to something different from null, so that currentRun.defines works
           phase = run.typerPhase // need to set a phase to something <= typerPhase, otherwise implicits in typedSelect will be disabled
           globalPhase = run.typerPhase // amazing... looks like phase and globalPhase are different things, so we need to set them separately
-          currentTyper.context.initRootContext() // need to manually set context mode, otherwise typer.silent will throw exceptions
+          currCtx.initRootContext() // need to manually set context mode, otherwise typer.silent will throw exceptions
           reporter.reset()
 
-          val expr3 = withContext(transform(currentTyper, expr2))
-          var (dummies1, result) = expr3 match {
-            case Block(dummies, result) => ((dummies, result))
-            case result                 => ((Nil, result))
-          }
+          val (binders, transformed) =
+            currCtx.withImplicits(enabled = !withImplicitViewsDisabled) {
+              currCtx.withMacros(enabled = !withMacrosDisabled) {
+                transform(currentTyper, exprBound)
+              }
+            } match {
+              case Block(binders, transformed) => (binders, transformed)
+              case transformed                 => (Nil, transformed)
+            }
+
           val invertedIndex = freeTerms map (_.swap)
-          result = new Transformer {
+          val indexed = new Transformer {
             override def transform(tree: Tree): Tree =
               tree match {
                 case Ident(name: TermName) if invertedIndex contains name =>
@@ -158,10 +163,10 @@ abstract class ToolBoxFactory[U <: JavaUniverse](val u: U) { factorySelf =>
                 case _ =>
                   super.transform(tree)
               }
-          }.transform(result)
-          new TreeTypeSubstituter(dummies1 map (_.symbol), dummies1 map (dummy => SingleType(NoPrefix, invertedIndex(dummy.symbol.name.toTermName)))).traverse(result)
-          result
-        })
+          }.transform(transformed)
+          new TreeTypeSubstituter(binders map (_.symbol), binders map (b => SingleType(NoPrefix, invertedIndex(b.symbol.name.toTermName)))).traverse(indexed)
+          indexed
+        }
       }
 
       def typecheck(expr: Tree, pt: Type, mode: scala.reflect.internal.Mode, silent: Boolean, withImplicitViewsDisabled: Boolean, withMacrosDisabled: Boolean): Tree =