hooks for plugins to override Global.analyzer

As discussed a couple weeks ago, submitting this to formalize the hacks
that I used in macro paradise for 2.10, so that it continues working
after possible refactorings in 2.11.

One of the strategies to implement this would be to make a list of
functions overridden by the plugin and then to reuse the analyzer
plugins architecture to introduce them as hooks. However:
1) The list is quite big and disparate (Namers.enterSym,
Namers.ensureCompanionObject, Typers.reallyExists, Typers.typed1,
Typers.typedTemplate, Typers.typedBlock, Typers.typedClassDef).
2) The list doesn't correspond to the spirit of analyzer plugins that
modify return types of namer/typer functions rather than override them.
3) There's no guarantee that later on paradise won't need to override
additional functionality of namer/typer, requiring new hacks.

Another strategy lets plugins suggest their own analyzers to the compiler.
It enables augmenting namer/typer with arbitrary functionality, providing
ultimate flexibility. Shortcomings:
1) If multiple plugins want to install their own analyzers, it won't work
(but such situations can be detected and meaningful errors can be reported).
One can argue though, that even if we provided finer-grained API for
such plugins, it wouldn't work anyway, because e.g. it's hard to imagine
several plugins robustly applying their modifications to Namers.enterSym.

None of the outlined two strategies is ideal, however, the second one
makes more sense to me, because shortcoming #3 of the first one seems to
defeat the idea of introducing the hooks into the compiler in the first place.
Therefore this patch implements the second strategy.

Author: xeno-by

src/compiler/scala/tools/nsc/Global.scala

@@ -436,9 +436,28 @@ class Global(var currentSettings: Settings, var reporter: Reporter)
   // I only changed analyzer.
   //
   // factory for phases: namer, packageobjects, typer
-  lazy val analyzer = new {
-    val global: Global.this.type = Global.this
-  } with Analyzer
+  private var analyzerInitializing = false
+  lazy val analyzer = {
+    def defaultAnalyzer = new { val global: Global.this.type = Global.this } with Analyzer
+    if (!analyzerInitializing) {
+      analyzerInitializing = true
+      val computedAnalyzer = {
+        earlyPlugins.flatMap(_.analyzer) match {
+          case Nil => defaultAnalyzer
+          case analyzer :: Nil => analyzer
+          case analyzer :: others =>
+            val offenders = earlyPlugins.filter(_.analyzer.nonEmpty).map(_.name).mkString(", ")
+            globalError(s"multiple plugins: $offenders attempt to replace the analyzer")
+            defaultAnalyzer
+        }
+      }
+      analyzerInitializing = false
+      computedAnalyzer.asInstanceOf[Analyzer{ val global: Global.this.type }]
+    } else {
+      globalError(s"one of the plugins attempted to induce analyzer initialization loop")
+      defaultAnalyzer
+    }
+  }
 
   // phaseName = "patmat"
   object patmat extends {

src/compiler/scala/tools/nsc/plugins/Plugin.scala

@@ -8,6 +8,7 @@ package plugins
 
 import scala.tools.nsc.io.{ Jar }
 import scala.tools.nsc.util.ScalaClassLoader
+import scala.tools.nsc.typechecker.Analyzer
 import scala.reflect.io.{ Directory, File, Path }
 import java.io.InputStream
 import java.util.zip.ZipException
@@ -56,6 +57,25 @@ abstract class Plugin {
   val optionsHelp: Option[String] = None
 }
 
+/** Information about a plugin loaded from a jar file.
+ *
+ *  In addition to normal functionality exposed by `Plugin`,
+ *  `EarlyPlugin` lets its users modify the very backbone of the compiler:
+ *  the `analyzer` component that spawns namers and typers.
+ *
+ *  The concrete subclass must have a one-argument constructor
+ *  that accepts an instance of `global`.
+ *  {{{
+ *    (val global: Global)
+ *  }}}
+ */
+abstract class EarlyPlugin extends Plugin {
+  /** The custom analyzer that this plugin requires, if any.
+   *  If multiple plugins require custom analyzers, an error is raised.
+   */
+  val analyzer: Option[Analyzer] = None
+}
+
 /** ...
  *
  *  @author Lex Spoon
@@ -145,3 +165,9 @@ object Plugin {
     (clazz getConstructor classOf[Global] newInstance global).asInstanceOf[Plugin]
   }
 }
+
+object EarlyPlugin {
+  def instantiate(clazz: Class[_], global: Global): EarlyPlugin = {
+    Plugin.instantiate(clazz, global).asInstanceOf[EarlyPlugin]
+  }
+}

src/compiler/scala/tools/nsc/plugins/Plugins.scala

@@ -19,12 +19,7 @@ import scala.tools.util.PathResolver.Defaults
 trait Plugins {
   self: Global =>
 
-  /** Load a rough list of the plugins.  For speed, it
-   *  does not instantiate a compiler run.  Therefore it cannot
-   *  test for same-named phases or other problems that are
-   *  filtered from the final list of plugins.
-   */
-  protected def loadRoughPluginsList(): List[Plugin] = {
+  protected lazy val (earlyPluginClasses, latePluginClasses) = {
     val jars = settings.plugin.value map Path.apply
     def injectDefault(s: String) = if (s.isEmpty) Defaults.scalaPluginPath else s
     val dirs = (settings.pluginsDir.value split File.pathSeparator).toList map injectDefault map Path.apply
@@ -33,14 +28,21 @@ trait Plugins {
     // Explicit parameterization of recover to suppress -Xlint warning about inferred Any
     errors foreach (_.recover[Any] { case e: Exception => inform(e.getMessage) })
     val classes = goods map (_.get)  // flatten
-
-    // Each plugin must only be instantiated once. A common pattern
-    // is to register annotation checkers during object construction, so
-    // creating multiple plugin instances will leave behind stale checkers.
-    classes map (Plugin.instantiate(_, this))
+    classes.partition(classOf[EarlyPlugin].isAssignableFrom(_))
   }
 
-  protected lazy val roughPluginsList: List[Plugin] = loadRoughPluginsList()
+  // Each plugin must only be instantiated once. A common pattern
+  // is to register annotation checkers during object construction, so
+  // creating multiple plugin instances will leave behind stale checkers.
+  lazy val earlyPlugins = earlyPluginClasses map (EarlyPlugin.instantiate(_, this))
+  protected lazy val latePlugins: List[Plugin] = latePluginClasses map (Plugin.instantiate(_, this))
+
+  /** Load a rough list of the plugins.  For speed, it
+   *  does not instantiate a compiler run.  Therefore it cannot
+   *  test for same-named phases or other problems that are
+   *  filtered from the final list of plugins.
+   */
+  protected lazy val roughPluginsList: List[Plugin] = earlyPlugins ++ latePlugins
 
   /** Load all available plugins.  Skips plugins that
    *  either have the same name as another one, or which

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

@@ -29,9 +29,10 @@ trait Analyzer extends AnyRef
   val global : Global
   import global._
 
-  object namerFactory extends {
+  lazy val namerFactory = new NamerFactory
+
+  class NamerFactory extends SubComponent {
     val global: Analyzer.this.global.type = Analyzer.this.global
-  } with SubComponent {
     val phaseName = "namer"
     val runsAfter = List[String]("parser")
     val runsRightAfter = None
@@ -45,9 +46,10 @@ trait Analyzer extends AnyRef
     }
   }
 
-  object packageObjects extends {
+  lazy val packageObjects = new PackageObjects
+
+  class PackageObjects extends SubComponent {
     val global: Analyzer.this.global.type = Analyzer.this.global
-  } with SubComponent {
     val phaseName = "packageobjects"
     val runsAfter = List[String]()
     val runsRightAfter= Some("namer")
@@ -73,10 +75,11 @@ trait Analyzer extends AnyRef
     }
   }
 
-  object typerFactory extends {
-    val global: Analyzer.this.global.type = Analyzer.this.global
-  } with SubComponent {
+  lazy val typerFactory = new TyperFactory
+
+  class TyperFactory extends SubComponent {
     import scala.reflect.internal.TypesStats.typerNanos
+    val global: Analyzer.this.global.type = Analyzer.this.global
     val phaseName = "typer"
     val runsAfter = List[String]()
     val runsRightAfter = Some("packageobjects")

src/partest/scala/tools/partest/nest/FileManager.scala

@@ -158,7 +158,7 @@ trait FileManager extends FileUtil {
     val xprefix          = "-Xplugin:"
     val (xplugs, others) = args partition (_ startsWith xprefix)
     val Xplugin          = if (xplugs.isEmpty) Nil else List(xprefix +
-      (xplugs map (_ stripPrefix xprefix) flatMap (_ split pathSeparator) map absolutize mkString pathSeparator)
+      (xplugs map (_ stripPrefix xprefix) flatMap (_ split ",") map absolutize mkString ",")
     )
     SCALAC_OPTS.toList ::: others ::: Xplugin
   }

test/files/neg/analyzerReplacingPlugins-a.check

@@ -0,0 +1,2 @@
+error: multiple plugins: analyzerReplacingPlugin1, analyzerReplacingPlugin2 attempt to replace the analyzer
+one error found

test/files/neg/analyzerReplacingPlugins-a/sample_1.flags

@@ -0,0 +1 @@
+-Xplugin:files/plugins/analyzerReplacingPlugin1.jar,files/plugins/analyzerReplacingPlugin2.jar

test/files/neg/analyzerReplacingPlugins-a/sample_1.scala

@@ -0,0 +1,3 @@
+object Test extends App {
+  println("hello")
+}

test/files/neg/analyzerReplacingPlugins-b.check

@@ -0,0 +1,2 @@
+error: one of the plugins attempted to induce analyzer initialization loop
+one error found

test/files/neg/analyzerReplacingPlugins-b/ploogin_1.scala

@@ -0,0 +1,18 @@
+package analyzerReplacingPlugins
+
+import scala.tools.nsc.{ Global, Phase }
+import scala.tools.nsc.plugins.{ EarlyPlugin, PluginComponent }
+import scala.tools.nsc.typechecker.Analyzer
+import scala.reflect.io.Path
+import scala.reflect.io.File
+import scala.reflect.internal.Mode
+
+/** A test plugin.  */
+class Ploogin(val global: Global) extends EarlyPlugin {
+  import global._
+
+  val name = "analyzerReplacingPlugin"
+  val description = "A sample analyzer replacing plugin for testing."
+  val components = Nil
+  override val analyzer: Option[Analyzer] = Some(global.analyzer)
+}

test/files/neg/analyzerReplacingPlugins-b/sample_2.flags

@@ -0,0 +1 @@
+-Xplugin:.

test/files/neg/analyzerReplacingPlugins-b/sample_2.scala

@@ -0,0 +1,3 @@
+object Test extends App {
+  println("hello")
+}

test/files/neg/analyzerReplacingPlugins-b/scalac-plugin.xml

@@ -0,0 +1,4 @@
+<plugin>
+  <name>analyzer-replacing-plugin</name>
+  <classname>analyzerReplacingPlugins.Ploogin</classname>
+</plugin>

test/files/plugins/analyzerReplacingPlugin1.jar.desired.sha1

@@ -0,0 +1 @@
+7ecf05c5d5e9038462b5cee3f4a753a42e108ed4 ?analyzerReplacingPlugin1.jar

test/files/plugins/analyzerReplacingPlugin2.jar.desired.sha1

@@ -0,0 +1 @@
+7e02a93333895a56fb807676bc496856e23e5a97 ?analyzerReplacingPlugin2.jar

test/files/run/analyzerReplacingPlugins.check

@@ -0,0 +1 @@
+hello world

test/files/run/analyzerReplacingPlugins/ploogin_1.scala

@@ -0,0 +1,31 @@
+package analyzerReplacingPlugins
+
+import scala.tools.nsc.{ Global, Phase }
+import scala.tools.nsc.plugins.{ EarlyPlugin, PluginComponent }
+import scala.tools.nsc.typechecker.Analyzer
+import scala.reflect.io.Path
+import scala.reflect.io.File
+import scala.reflect.internal.Mode
+
+/** A test plugin.  */
+class Ploogin(val global: Global) extends EarlyPlugin {
+  import global._
+
+  val name = "analyzerReplacingPlugin"
+  val description = "A sample analyzer replacing plugin for testing."
+  val components = Nil
+  override val analyzer: Option[Analyzer] = Some(new { val global: Ploogin.this.global.type = Ploogin.this.global } with MyAnalyzer)
+
+  private trait MyAnalyzer extends Analyzer {
+    val global: Ploogin.this.global.type
+    override def newTyper(context: Context) = new Typer(context) {
+      override def typed1(tree: Tree, mode: Mode, pt: Type): Tree = {
+        val tree1 = tree match {
+          case tree @ Literal(Constant("hello")) if tree.tpe == null => Literal(Constant("hello world"))
+          case _ => tree
+        }
+        super.typed1(tree1, mode, pt)
+      }
+    }
+  }
+}

test/files/run/analyzerReplacingPlugins/sample_2.flags

@@ -0,0 +1 @@
+-Xplugin:.

test/files/run/analyzerReplacingPlugins/sample_2.scala

@@ -0,0 +1,3 @@
+object Test extends App {
+  println("hello")
+}

test/files/run/analyzerReplacingPlugins/scalac-plugin.xml

@@ -0,0 +1,4 @@
+<plugin>
+  <name>analyzer-replacing-plugin</name>
+  <classname>analyzerReplacingPlugins.Ploogin</classname>
+</plugin>