SI-6623 -Yrepl-use-magic-imports avoids nesting $iw wrappers

Rather than adding a wrapper object for each import in the session
history, just use a single wrapper preceded by the imports which
have been interspersed with a magic import to bump context depth.

Code is still ordinarily wrapped in a `$read` object.

This is a step toward 6623-like transparency.

`retronym` takes the blame for this innovation.
`adriaanm` collaborated in its commission.
`somsnytt` batted clean-up.

Author: retronym

src/compiler/scala/tools/nsc/settings/ScalaSettings.scala

@@ -237,6 +237,7 @@ trait ScalaSettings extends AbsScalaSettings
   val YmacroFresh     = BooleanSetting    ("-Ymacro-global-fresh-names", "Should fresh names in macros be unique across all compilation units")
   val Yreplsync       = BooleanSetting    ("-Yrepl-sync", "Do not use asynchronous code for repl startup")
   val Yreplclassbased = BooleanSetting    ("-Yrepl-class-based", "Use classes to wrap REPL snippets instead of objects")
+  val YreplMagicImport = BooleanSetting    ("-Yrepl-use-magic-imports", "In the code the wraps REPL snippes, use magic imports to rather than nesting wrapper object/classes")
   val Yreploutdir     = StringSetting     ("-Yrepl-outdir", "path", "Write repl-generated classfiles to given output directory (use \"\" to generate a temporary dir)" , "")
   val YmethodInfer    = BooleanSetting    ("-Yinfer-argument-types", "Infer types for arguments of overridden methods.")
   val YdisableFlatCpCaching  = BooleanSetting    ("-YdisableFlatCpCaching", "Do not cache flat classpath representation of classpath elements from jars across compiler instances.")

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

@@ -241,7 +241,7 @@ trait Contexts { self: Analyzer =>
     /** Equivalent to `imports.headOption`, but more efficient */
     def firstImport: Option[ImportInfo] = outer.firstImport
     protected[Contexts] def importOrNull: ImportInfo = null
-    /** A root import is never unused and always bumps context depth. (e.g scala._ / Predef._ / java.lang._) */
+    /** A root import is never unused and always bumps context depth. (e.g scala._ / Predef._ and magic REPL imports) */
     def isRootImport: Boolean = false
 
     /** Types for which implicit arguments are currently searched */
@@ -490,7 +490,7 @@ trait Contexts { self: Analyzer =>
 
       // The blank canvas
       val c = if (isImport) {
-        val isRootImport = !tree.pos.isDefined
+        val isRootImport = !tree.pos.isDefined || isReplImportWrapperImport(tree)
         new ImportContext(tree, owner, scope, unit, this, isRootImport, innerDepth(isRootImport), reporter)
       } else
         new Context(tree, owner, scope, unit, this, innerDepth(isRootImport = false), reporter)
@@ -1101,6 +1101,16 @@ trait Contexts { self: Analyzer =>
       }
     }
 
+
+    private def isReplImportWrapperImport(tree: Tree): Boolean = {
+      tree match {
+        case Import(expr, selector :: Nil) =>
+          // Just a syntactic check to avoid forcing typechecking of imports
+          selector.name.string_==(nme.INTERPRETER_IMPORT_LEVEL_UP) && owner.enclosingTopLevelClass.isInterpreterWrapper
+        case _ => false
+      }
+    }
+
   } //class Context
 
   /** Find the symbol of a simple name starting from this context.

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

@@ -536,8 +536,10 @@ trait Namers extends MethodSynthesis {
       val Import(expr, selectors) = tree
       val base = expr.tpe
 
-      def checkNotRedundant(pos: Position, from: Name, to0: Name) {
-        def check(to: Name) = {
+      // warn proactively if specific import loses to definition in scope,
+      // since it may result in desired implicit not imported into scope.
+      def checkNotRedundant(pos: Position, from: Name, to0: Name): Unit = {
+        def check(to: Name): Unit = {
           val e = context.scope.lookupEntry(to)
 
           if (e != null && e.owner == context.scope && e.sym.exists)
@@ -1820,7 +1822,6 @@ trait Namers extends MethodSynthesis {
       }
     }
 
-
     /** Given a case class
      *   case class C[Ts] (ps: Us)
      *  Add the following methods to toScope:

src/partest-extras/scala/tools/partest/ReplTest.scala

@@ -67,6 +67,21 @@ trait Welcoming { this: ReplTest =>
   override def welcoming = true
 }
 
+/** Strip Any.toString's id@abcdef16 hashCodes. These are generally at end of result lines. */
+trait Hashless extends ReplTest {
+  import Hashless._
+  override def normalize(s: String) = {
+    val n = super.normalize(s)
+    n match {
+      case hashless(prefix) => s"$prefix@XXXXXXXX"
+      case _ => n
+    }
+  }
+}
+object Hashless {
+  private val hashless = "(.*)@[a-fA-F0-9]+".r
+}
+
 /** Run a REPL test from a session transcript.
  *  The `session` is read from the `.check` file.
  */

src/reflect/scala/reflect/internal/StdNames.scala

@@ -332,7 +332,9 @@ trait StdNames {
     val EXCEPTION_RESULT_PREFIX        = "exceptionResult"
     val EXPAND_SEPARATOR_STRING        = "$$"
     val FRESH_TERM_NAME_PREFIX         = "x$"
+    val INTERPRETER_IMPORT_LEVEL_UP    = NameTransformer.encode("{{")
     val INTERPRETER_IMPORT_WRAPPER     = "$iw"
+    val INTERPRETER_WRAPPER            = "$read"
     val LOCALDUMMY_PREFIX              = "<local "       // owner of local blocks
     val PROTECTED_PREFIX               = "protected$"
     val PROTECTED_SET_PREFIX           = PROTECTED_PREFIX + "set"
@@ -392,7 +394,7 @@ trait StdNames {
     def isLocalName(name: Name)             = name endsWith LOCAL_SUFFIX_STRING
     def isLoopHeaderLabel(name: Name)       = (name startsWith WHILE_PREFIX) || (name startsWith DO_WHILE_PREFIX)
     def isProtectedAccessorName(name: Name) = name startsWith PROTECTED_PREFIX
-    def isReplWrapperName(name: Name)       = name containsName INTERPRETER_IMPORT_WRAPPER
+    def isReplWrapperName(name: Name)       = (name containsName INTERPRETER_WRAPPER) || (name containsName INTERPRETER_IMPORT_WRAPPER)
     def isSetterName(name: Name)            = name endsWith SETTER_SUFFIX
     def isTraitSetterName(name: Name)       = isSetterName(name) && (name containsName TRAIT_SETTER_SEPARATOR_STRING)
     def isSingletonName(name: Name)         = name endsWith SINGLETON_SUFFIX

src/reflect/scala/reflect/internal/Symbols.scala

@@ -706,11 +706,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     final def isOverridableMember  = !(isClass || isEffectivelyFinal || isTypeParameter) && safeOwner.isClass
 
     /** Does this symbol denote a wrapper created by the repl? */
-    final def isInterpreterWrapper = (
-         (this hasFlag MODULE)
-      && isTopLevel
-      && nme.isReplWrapperName(name)
-    )
+    final def isInterpreterWrapper = isTopLevel && nme.isReplWrapperName(name)
 
     /** In our current architecture, symbols for top-level classes and modules
      *  are created as dummies. Package symbols just call newClass(name) or newModule(name) and
@@ -874,7 +870,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     final def skipConstructor: Symbol = if (isConstructor) owner else this
 
     /** Conditions where we omit the prefix when printing a symbol, to avoid
-     *  unpleasantries like Predef.String, $iw.$iw.Foo and <empty>.Bippy.
+     *  unpleasantries like Predef.String, $read.$iw.Foo and <empty>.Bippy.
      */
     final def isOmittablePrefix = /*!settings.debug.value &&*/ {
       // scala/bug#5941 runtime reflection can have distinct symbols representing `package scala` (from different mirrors)
@@ -886,7 +882,7 @@ trait Symbols extends api.Symbols { self: SymbolTable =>
     def isEmptyPrefix = (
          isEffectiveRoot                      // has no prefix for real, <empty> or <root>
       || isAnonOrRefinementClass              // has uninteresting <anon> or <refinement> prefix
-      || nme.isReplWrapperName(name)          // has ugly $iw. prefix (doesn't call isInterpreterWrapper due to nesting)
+      || nme.isReplWrapperName(name)          // $read.$iw.Foo or $read.INSTANCE.$iw.Foo
     )
     def isFBounded = info match {
       case TypeBounds(_, _) => info.baseTypeSeq exists (_ contains this)

src/repl/scala/tools/nsc/interpreter/IMain.scala

@@ -14,7 +14,6 @@ package scala
 package tools.nsc
 package interpreter
 
-import PartialFunction.cond
 import scala.language.implicitConversions
 import scala.collection.mutable
 import scala.concurrent.{ExecutionContext, Future}
@@ -76,6 +75,7 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
   def showDirectory() = replOutput.show(out)
 
   lazy val isClassBased: Boolean = settings.Yreplclassbased.value
+  private[interpreter] lazy val useMagicImport: Boolean = settings.YreplMagicImport.value
 
   private[nsc] var printResults               = true        // whether to print result lines
   private[nsc] var totalSilence               = false       // whether to print anything
@@ -318,13 +318,11 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
   def originalPath(name: String): String = originalPath(TermName(name))
   def originalPath(name: Name): String   = translateOriginalPath(typerOp path name)
   def originalPath(sym: Symbol): String  = translateOriginalPath(typerOp path sym)
+
   /** For class based repl mode we use an .INSTANCE accessor. */
   val readInstanceName = if (isClassBased) ".INSTANCE" else ""
   def translateOriginalPath(p: String): String = {
-    if (isClassBased) {
-      val readName = java.util.regex.Matcher.quoteReplacement(sessionNames.read)
-      p.replaceFirst(readName, readName + readInstanceName)
-    } else p
+    if (isClassBased) p.replace(sessionNames.read, sessionNames.read + readInstanceName) else p
   }
   def flatPath(sym: Symbol): String      = flatOp shift sym.javaClassName
 
@@ -335,7 +333,7 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
 
   /** If path represents a class resource in the default package,
    *  see if the corresponding symbol has a class file that is a REPL artifact
-   *  residing at a different resource path. Translate X.class to $line3/$read$$iw$$iw$X.class.
+   *  residing at a different resource path. Translate X.class to $line3/$read$iw$X.class.
    */
   def translateSimpleResource(path: String): Option[String] = {
     if (!(path contains '/') && (path endsWith ".class")) {
@@ -711,9 +709,9 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
 
       val unwrapped = unwrap(t)
 
-      // Example input: $line3.$read$$iw$$iw$
+      // Example input: $line3.$read$$iw$
       val classNameRegex = (naming.lineRegex + ".*").r
-      def isWrapperInit(x: StackTraceElement) = cond(x.getClassName) {
+      def isWrapperInit(x: StackTraceElement) = PartialFunction.cond(x.getClassName) {
         case classNameRegex() if x.getMethodName == nme.CONSTRUCTOR.decoded => true
       }
       val stackTrace = unwrapped stackTracePrefixString (!isWrapperInit(_))
@@ -863,7 +861,6 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
 
     /** generate the source code for the object that computes this request */
     abstract class Wrapper extends IMain.CodeAssembler[MemberHandler] {
-      def path = originalPath("$intp")
       def envLines = {
         if (!isReplPower) Nil // power mode only for now
         else {
@@ -884,6 +881,8 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
       /** A format string with %s for $read, specifying the wrapper definition. */
       def preambleHeader: String
 
+      def postamble: String
+
       /** Like preambleHeader for an import wrapper. */
       def prewrap: String = preambleHeader + "\n"
 
@@ -990,11 +989,7 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
     }
 
     // the type symbol of the owner of the member that supplies the result value
-    lazy val resultSymbol = {
-      val sym = lineRep.resolvePathToSymbol(fullAccessPath)
-      // plow through the INSTANCE member when -Yrepl-class-based
-      if (sym.isTerm && sym.nameString == "INSTANCE") sym.typeSignature.typeSymbol else sym
-    }
+    lazy val resultSymbol = lineRep.resolvePathToSymbol(fullAccessPath)
 
     def applyToResultMember[T](name: Name, f: Symbol => T) = exitingTyper(f(resultSymbol.info.nonPrivateDecl(name)))
 
@@ -1007,7 +1002,10 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
     /** Types of variables defined by this request. */
     lazy val compilerTypeOf = typeMap[Type](x => x) withDefaultValue NoType
     /** String representations of same. */
-    lazy val typeOf         = typeMap[String](tp => exitingTyper(tp.toString))
+    lazy val typeOf         = typeMap[String](tp => exitingTyper {
+      val s = tp.toString
+      if (isClassBased) s.stripPrefix("INSTANCE.") else s
+    })
 
     lazy val definedSymbols = (
       termNames.map(x => x -> applyToResultMember(x, x => x)) ++
@@ -1060,7 +1058,7 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
   def typeOfTerm(id: String): Type = symbolOfTerm(id).tpe
 
   // Given the fullName of the symbol, reflectively drill down the path
-  def valueOfTerm(id: String): Option[Any] = {
+  def valueOfTerm(id: String): Option[Any] = exitingTyper {
     def value(fullName: String) = {
       val mirror = runtimeMirror
       import mirror.universe.{Symbol, InstanceMirror, TermName}
@@ -1088,7 +1086,7 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
                 mirror.reflect(mirrored.reflectMethod(s.asMethod).apply())
               }
               else {
-                assert(false, originalPath(s))
+                assert(false, fullName)
                 inst
               }
             loop(i, s, rest)
@@ -1142,6 +1140,7 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends
       )
     )
   }
+  // this is harder than getting the typed trees and fixing up the string to emit that reports types
   def cleanMemberDecl(owner: Symbol, member: Name): Type =
     cleanTypeAfterTyper(owner.info nonPrivateDecl member)
 
@@ -1267,6 +1266,7 @@ object IMain {
   //   $line3.$read$$iw$$iw$Bippy@4a6a00ca
   private def removeLineWrapper(s: String) = s.replaceAll("""\$line\d+[./]\$(read|eval|print)[$.]""", "")
   private def removeIWPackages(s: String)  = s.replaceAll("""\$(iw|read|eval|print)[$.]""", "")
+  @deprecated("Use intp.naming.unmangle.", "2.12.0-M5")
   def stripString(s: String)               = removeIWPackages(removeLineWrapper(s))
 
   private[interpreter] def withSuppressedSettings[A](settings: Settings, global: => Global)(body: => A): A = {