From d32e12050b1653c459d976c01dad3bdb3e01fc4c Mon Sep 17 00:00:00 2001
From: Roman Tkalenko <tkroman@users.noreply.github.com>
Date: Sat, 10 Dec 2016 16:55:08 +0200
Subject: [PATCH] Fixed #515 (#525)

---
 .../interp/CompilerCompatibility.scala        | 40 ++++++++++++++-----
 .../scala/ammonite/session/ProjectTests.scala | 10 ++++-
 2 files changed, 39 insertions(+), 11 deletions(-)

diff --git a/amm/interp/src/main/scala-2.12/ammonite/interp/CompilerCompatibility.scala b/amm/interp/src/main/scala-2.12/ammonite/interp/CompilerCompatibility.scala
index abdd0d60c..886565611 100644
--- a/amm/interp/src/main/scala-2.12/ammonite/interp/CompilerCompatibility.scala
+++ b/amm/interp/src/main/scala-2.12/ammonite/interp/CompilerCompatibility.scala
@@ -2,59 +2,72 @@ package ammonite.interp
 
 import ammonite.runtime.Classpath
 import ammonite.util.ImportData
-
 import scala.reflect.internal.util.Position
 import scala.reflect.io
 import scala.reflect.io.{AbstractFile, FileZipArchive, VirtualDirectory}
 import scala.tools.nsc
 import scala.tools.nsc.backend.JavaPlatform
 import scala.tools.nsc.classpath._
-import scala.tools.nsc.{Global, Settings}
+import scala.tools.nsc.{Global, GlobalSymbolLoaders, Settings}
 import scala.tools.nsc.interactive.{Global => InteractiveGlobal}
 import scala.tools.nsc.plugins.Plugin
 import scala.tools.nsc.reporters.AbstractReporter
+import scala.tools.nsc.symtab.BrowsingLoaders
 import scala.tools.nsc.typechecker.Analyzer
 
 object CompilerCompatibility {
-  def analyzer(g: Global, cl: ClassLoader): Analyzer { val global: g.type } =
+  def analyzer(g: Global, cl: ClassLoader): Analyzer { val global: g.type } = {
     new { val global: g.type = g } with Analyzer {
       override def findMacroClassLoader() = cl
     }
+  }
 
   type InteractiveAnalyzer = scala.tools.nsc.interactive.InteractiveAnalyzer
 
-  def interactiveAnalyzer(g: InteractiveGlobal, cl: ClassLoader)
-                         : InteractiveAnalyzer { val global: g.type } =
+  def interactiveAnalyzer(g: InteractiveGlobal,
+                          cl: ClassLoader): InteractiveAnalyzer { val global: g.type } = {
     new { val global: g.type = g } with InteractiveAnalyzer {
       override def findMacroClassLoader() = cl
     }
+  }
 
-  def trees(g: Global)(parser: g.syntaxAnalyzer.UnitParser): Seq[Global#Tree] =
+  def trees(g: Global)(parser: g.syntaxAnalyzer.UnitParser): Seq[Global#Tree] = {
     parser.parseStatsOrPackages()
+  }
 
-  def pluginInit(plugin: Plugin, options: List[String], error: String => Unit): Boolean =
+  def pluginInit(plugin: Plugin, options: List[String], error: String => Unit): Boolean = {
     plugin.init(options, error)
-
+  }
 }
+
 object GlobalInitCompat{
+
   def initInteractiveGlobal(settings: Settings,
                             reporter: AbstractReporter,
                             jcp: AggregateClassPath,
-                            evalClassloader: ClassLoader) = {
+                            evalClassloader: ClassLoader): InteractiveGlobal = {
     new nsc.interactive.Global(settings, reporter) { g =>
       // Actually jcp, avoiding a path-dependent type issue in 2.10 here
       override def classPath = jcp
 
+      override lazy val platform: ThisPlatform = new GlobalPlatform {
+        override val global = g
+        override val settings = g.settings
+        override val classPath = jcp
+      }
+
       override lazy val analyzer = CompilerCompatibility.interactiveAnalyzer(g, evalClassloader)
     }
   }
+
   def initGlobal(settings: Settings,
                  reporter: AbstractReporter,
                  plugins0: Vector[(String, Class[_])],
                  jcp: AggregateClassPath,
                  evalClassloader: ClassLoader,
                  importsLen: => Int,
-                 updateLastImports: Seq[ImportData] => Unit) = {
+                 updateLastImports: Seq[ImportData] => Unit): Global = {
+
     new nsc.Global(settings, reporter) { g =>
       override lazy val plugins = List(new AmmonitePlugin(g, updateLastImports, importsLen)) ++ {
         for {
@@ -73,9 +86,16 @@ object GlobalInitCompat{
       // Actually jcp, avoiding a path-dependent type issue in 2.10 here
       override def classPath = jcp
 
+      override lazy val platform: ThisPlatform = new GlobalPlatform {
+        override val global = g
+        override val settings = g.settings
+        override val classPath = jcp
+      }
+
       override lazy val analyzer = CompilerCompatibility.analyzer(g, evalClassloader)
     }
   }
+
   /**
     * Code to initialize random bits and pieces that are needed
     * for the Scala compiler to function, common between the
diff --git a/amm/src/test/scala/ammonite/session/ProjectTests.scala b/amm/src/test/scala/ammonite/session/ProjectTests.scala
index ecc9cae59..ccc10af98 100644
--- a/amm/src/test/scala/ammonite/session/ProjectTests.scala
+++ b/amm/src/test/scala/ammonite/session/ProjectTests.scala
@@ -291,7 +291,15 @@ object ProjectTests extends TestSuite{
       //      res9: spire.math.Rational = 2/3
 
     }
-
+    'pegdown{
+      check.session(
+        s"""
+           @ import $$ivy.`org.pegdown:pegdown:1.6.0`
+
+           @ org.pegdown.ast.SimpleNode.Type.HRule
+           res1: org.pegdown.ast.SimpleNode.Type = HRule
+         """)
+    }
   }
 }