diff options
Diffstat (limited to 'src')
16 files changed, 155 insertions, 110 deletions
diff --git a/src/compiler/scala/reflect/runtime/JavaToScala.scala b/src/compiler/scala/reflect/runtime/JavaToScala.scala index 18db32c3bb..b8c8718590 100644 --- a/src/compiler/scala/reflect/runtime/JavaToScala.scala +++ b/src/compiler/scala/reflect/runtime/JavaToScala.scala @@ -1,7 +1,7 @@ package scala.reflect package runtime -import java.lang.{ Class => jClass, Package => jPackage } +import java.lang.{ Class => jClass, Package => jPackage, ClassLoader => JClassLoader } import java.io.IOException import java.lang.reflect.{ Method => jMethod, @@ -26,16 +26,6 @@ import internal.Flags._ import scala.tools.nsc.util.ScalaClassLoader import scala.tools.nsc.util.ScalaClassLoader._ -class MultiCL(parent: ScalaClassLoader, others: ScalaClassLoader*) extends java.lang.ClassLoader(parent) { - override def findClass(name: String): jClass[_] = { - for (cl <- others) { - try { return cl.findClass(name) } - catch { case _: ClassNotFoundException => () } - } - super.findClass(name) - } -} - trait JavaToScala extends ConversionUtil { self: SymbolTable => import definitions._ @@ -44,11 +34,16 @@ trait JavaToScala extends ConversionUtil { self: SymbolTable => val global: JavaToScala.this.type = self } + protected def defaultReflectiveClassLoader(): JClassLoader = + Thread.currentThread.getContextClassLoader + /** Paul: It seems the default class loader does not pick up root classes, whereas the system classloader does. * Can you check with your newly acquired classloader fu whether this implementation makes sense? */ def javaClass(path: String): jClass[_] = - jClass.forName(path, false, new MultiCL(getClass.getClassLoader, java.lang.ClassLoader.getSystemClassLoader)) + javaClass(path, defaultReflectiveClassLoader()) + def javaClass(path: String, classLoader: JClassLoader): jClass[_] = + classLoader.loadClass(path) /** Does `path` correspond to a Java class with that fully qualified name? */ def isJavaClass(path: String): Boolean = diff --git a/src/compiler/scala/tools/nsc/Global.scala b/src/compiler/scala/tools/nsc/Global.scala index b798fe71ba..602ff6bf0e 100644 --- a/src/compiler/scala/tools/nsc/Global.scala +++ b/src/compiler/scala/tools/nsc/Global.scala @@ -1325,10 +1325,11 @@ object Global { // !!! The classpath isn't known until the Global is created, which is too // late, so we have to duplicate it here. Classpath is too tightly coupled, // it is a construct external to the compiler and should be treated as such. - val loader = ScalaClassLoader.fromURLs(new PathResolver(settings).result.asURLs) - val name = settings.globalClass.value - val clazz = Class.forName(name, true, loader) - val cons = clazz.getConstructor(classOf[Settings], classOf[Reporter]) + val parentLoader = settings.explicitParentLoader getOrElse getClass.getClassLoader + val loader = ScalaClassLoader.fromURLs(new PathResolver(settings).result.asURLs, parentLoader) + val name = settings.globalClass.value + val clazz = Class.forName(name, true, loader) + val cons = clazz.getConstructor(classOf[Settings], classOf[Reporter]) cons.newInstance(settings, reporter).asInstanceOf[Global] } diff --git a/src/compiler/scala/tools/nsc/backend/jvm/BytecodeWriters.scala b/src/compiler/scala/tools/nsc/backend/jvm/BytecodeWriters.scala index 228d4c6191..5b6e37e4fe 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/BytecodeWriters.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/BytecodeWriters.scala @@ -67,7 +67,7 @@ trait BytecodeWriters { def emitJavap(bytes: Array[Byte], javapFile: io.File) { val pw = javapFile.printWriter() - val javap = new Javap(ScalaClassLoader.getSystemLoader(), pw) { + val javap = new Javap(ScalaClassLoader.appLoader, pw) { override def findBytes(path: String): Array[Byte] = bytes } diff --git a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala index 1b6b50a793..0bd7109a0d 100644 --- a/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala +++ b/src/compiler/scala/tools/nsc/backend/jvm/GenJVM.scala @@ -12,7 +12,6 @@ import java.nio.ByteBuffer import scala.collection.{ mutable, immutable } import scala.reflect.internal.pickling.{ PickleFormat, PickleBuffer } import scala.tools.reflect.SigParser -import scala.tools.nsc.util.ScalaClassLoader import scala.tools.nsc.symtab._ import scala.reflect.internal.ClassfileConstants._ import ch.epfl.lamp.fjbg._ diff --git a/src/compiler/scala/tools/nsc/interpreter/ByteCode.scala b/src/compiler/scala/tools/nsc/interpreter/ByteCode.scala index 90d8fbb356..3059a8fb10 100644 --- a/src/compiler/scala/tools/nsc/interpreter/ByteCode.scala +++ b/src/compiler/scala/tools/nsc/interpreter/ByteCode.scala @@ -9,7 +9,7 @@ package interpreter import java.lang.reflect import java.util.concurrent.ConcurrentHashMap import util.ScalaClassLoader -import ScalaClassLoader.getSystemLoader +import ScalaClassLoader.appLoader import scala.reflect.NameTransformer._ object ByteCode { @@ -17,7 +17,7 @@ object ByteCode { * that the compiler will bootstrap, we have to use reflection. */ private lazy val DECODER: Option[AnyRef] = - for (clazz <- getSystemLoader.tryToLoadClass[AnyRef]("scala.tools.scalap.Decode$")) yield + for (clazz <- appLoader.tryToLoadClass[AnyRef]("scala.tools.scalap.Decode$")) yield clazz.getField(MODULE_INSTANCE_NAME).get(null) private def decoderMethod(name: String, args: JClass*): Option[reflect.Method] = { diff --git a/src/compiler/scala/tools/nsc/interpreter/ILoop.scala b/src/compiler/scala/tools/nsc/interpreter/ILoop.scala index 625bf2ae05..1f19740353 100644 --- a/src/compiler/scala/tools/nsc/interpreter/ILoop.scala +++ b/src/compiler/scala/tools/nsc/interpreter/ILoop.scala @@ -93,11 +93,13 @@ class ILoop(in0: Option[BufferedReader], protected val out: JPrintWriter) } class ILoopInterpreter extends IMain(settings, out) { + outer => + override lazy val formatting = new Formatting { def prompt = ILoop.this.prompt } override protected def createLineManager(): Line.Manager = - if (ReplPropsKludge.noThreadCreation(settings)) null else new Line.Manager { + if (ReplPropsKludge.noThreadCreation(settings)) null else new Line.Manager(outer.classLoader) { override def onRunaway(line: Line[_]): Unit = { val template = """ |// She's gone rogue, captain! Have to take her out! diff --git a/src/compiler/scala/tools/nsc/interpreter/IMain.scala b/src/compiler/scala/tools/nsc/interpreter/IMain.scala index e93d4897ca..b092574eaf 100644 --- a/src/compiler/scala/tools/nsc/interpreter/IMain.scala +++ b/src/compiler/scala/tools/nsc/interpreter/IMain.scala @@ -8,11 +8,7 @@ package interpreter import Predef.{ println => _, _ } import util.{ Set => _, _ } -import scala.collection.{ mutable, immutable } import scala.sys.BooleanProp -import Exceptional.unwrap -import ScalaClassLoader.URLClassLoader -import symtab.Flags import io.VirtualDirectory import scala.tools.nsc.io.AbstractFile import reporters._ @@ -23,7 +19,6 @@ import scala.tools.nsc.util.{ ScalaClassLoader, Exceptional, Indenter } import ScalaClassLoader.URLClassLoader import Exceptional.unwrap import scala.collection.{ mutable, immutable } -import scala.PartialFunction.{ cond, condOpt } import scala.util.control.Exception.{ ultimately } import IMain._ @@ -257,14 +252,17 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends def setExecutionWrapper(code: String) = _executionWrapper = code def clearExecutionWrapper() = _executionWrapper = "" - lazy val lineManager = createLineManager() + private var _lineManager: Line.Manager = createLineManager() + def lineManager = _lineManager /** interpreter settings */ lazy val isettings = new ISettings(this) /** Create a line manager. Overridable. */ protected def createLineManager(): Line.Manager = - if (ReplPropsKludge.noThreadCreation(settings)) null else new Line.Manager + createLineManager(classLoader) + protected def createLineManager(loader: ClassLoader): Line.Manager = + if (ReplPropsKludge.noThreadCreation(settings)) null else new Line.Manager(loader) /** Instantiate a compiler. Overridable. */ protected def newCompiler(settings: Settings, reporter: Reporter) = { @@ -298,6 +296,7 @@ class IMain(initialSettings: Settings, protected val out: JPrintWriter) extends def resetClassLoader() = { repldbg("Setting new classloader: was " + _classLoader) _classLoader = makeClassLoader() + _lineManager = createLineManager(_classLoader) } def classLoader: AbstractFileClassLoader = { if (_classLoader == null) diff --git a/src/compiler/scala/tools/nsc/interpreter/Line.scala b/src/compiler/scala/tools/nsc/interpreter/Line.scala index deaeb913d2..deec9fcc4e 100644 --- a/src/compiler/scala/tools/nsc/interpreter/Line.scala +++ b/src/compiler/scala/tools/nsc/interpreter/Line.scala @@ -18,7 +18,7 @@ import Line._ * waits on a condition indicating that either the line has * completed or failed. */ -class Line[+T](val code: String, body: => T) { +class Line[+T](val code: String, classLoader: ClassLoader, body: => T) { private var _state: State = Running private var _result: Any = null private var _caught: Throwable = null @@ -37,19 +37,18 @@ class Line[+T](val code: String, body: => T) { // private because it should be called by the manager. private def cancel() = if (running) setState(Cancelled) - // This is where the line thread is created and started. - private val _thread = io.daemonize { - try { - _result = body - setState(Done) - } - catch { - case x => - _caught = x - setState(Threw) - } + private def runAndSetState[T](body: => T) { + var ex: Throwable = null + + try { _result = body } + catch { case t => ex = t } + finally { setState( if (ex == null) Done else Threw ) } } + // This is where the line thread is created and started. + private val _thread: Thread = + io.newThread(_ setContextClassLoader classLoader)(runAndSetState(body)) + def state = _state def thread = _thread def alive = thread.isAlive @@ -76,7 +75,7 @@ object Line { case object Cancelled extends State case object Done extends State - class Manager { + class Manager(classLoader: ClassLoader) { /** Override to add behavior for runaway lines. This method will * be called if a line thread is still running five seconds after * it has been cancelled. @@ -91,7 +90,7 @@ object Line { _current = None } def set[T](code: String)(body: => T) = { - val line = new Line(code, body) + val line = new Line(code, classLoader, body) _current = Some(line) line } diff --git a/src/compiler/scala/tools/nsc/io/ClassAndJarInfo.scala b/src/compiler/scala/tools/nsc/io/ClassAndJarInfo.scala index 716358a653..d0a0b17494 100644 --- a/src/compiler/scala/tools/nsc/io/ClassAndJarInfo.scala +++ b/src/compiler/scala/tools/nsc/io/ClassAndJarInfo.scala @@ -6,7 +6,7 @@ package scala.tools.nsc package io -import java.net.URL +import java.net.{ URL, URLClassLoader } import java.io.IOException import collection.JavaConverters._ @@ -14,18 +14,20 @@ import collection.JavaConverters._ * a given Class object and similar common tasks. */ class ClassAndJarInfo[T: ClassManifest] { - val man = classManifest[T] - def clazz = man.erasure + val man = classManifest[T] + def clazz = man.erasure + def internalName = clazz.getName.replace('.', '/') + + def resourceURL = new URLClassLoader(Array[URL]()) getResource internalName + ".class" def baseOfPath(path: String) = path indexOf '!' match { - case -1 => path stripSuffix internalClassName + case -1 => path stripSuffix internalName + ".class" case idx => path take idx } + def simpleClassName = clazz.getName split """[$.]""" last def classUrl = clazz getResource simpleClassName + ".class" def codeSource = protectionDomain.getCodeSource() - def internalClassName = internalName + ".class" - def internalName = clazz.getName.replace('.', '/') def jarManifest = ( try new JManifest(jarManifestUrl.openStream()) catch { case _: IOException => new JManifest() } @@ -39,5 +41,4 @@ class ClassAndJarInfo[T: ClassManifest] { def rootFromLocation = Path(locationUrl.toURI.getPath()) def rootFromResource = Path(baseOfPath(classUrl.getPath) stripPrefix "file:") def rootPossibles = Iterator(rootFromResource, rootFromLocation) - def simpleClassName = clazz.getName split """[$.]""" last } diff --git a/src/compiler/scala/tools/nsc/io/package.scala b/src/compiler/scala/tools/nsc/io/package.scala index d0a1d88086..88679e6dce 100644 --- a/src/compiler/scala/tools/nsc/io/package.scala +++ b/src/compiler/scala/tools/nsc/io/package.scala @@ -25,9 +25,10 @@ package object io { def spawnFn[T](f: () => T): Future[T] = spawn(f()) // Create, start, and return a daemon thread - def daemonize(body: => Unit): Thread = { + def daemonize(body: => Unit): Thread = newThread(_ setDaemon true)(body) + def newThread(f: Thread => Unit)(body: => Unit): Thread = { val thread = new Thread(runnable(body)) - thread setDaemon true + f(thread) thread.start thread } diff --git a/src/compiler/scala/tools/nsc/util/ClassPath.scala b/src/compiler/scala/tools/nsc/util/ClassPath.scala index 1487b42843..1820bd190f 100644 --- a/src/compiler/scala/tools/nsc/util/ClassPath.scala +++ b/src/compiler/scala/tools/nsc/util/ClassPath.scala @@ -464,5 +464,16 @@ extends ClassPath[T] { class JavaClassPath( containers: IndexedSeq[ClassPath[AbstractFile]], context: JavaContext) -extends MergedClassPath[AbstractFile](containers, context) { +extends MergedClassPath[AbstractFile](containers, context) { } + +object JavaClassPath { + def fromURLs(urls: Seq[URL], context: JavaContext): JavaClassPath = { + val containers = { + for (url <- urls ; f = AbstractFile getURL url ; if f != null) yield + new DirectoryClassPath(f, context) + } + new JavaClassPath(containers.toIndexedSeq, context) + } + def fromURLs(urls: Seq[URL]): JavaClassPath = + fromURLs(urls, ClassPath.DefaultJavaContext) } diff --git a/src/compiler/scala/tools/nsc/util/ScalaClassLoader.scala b/src/compiler/scala/tools/nsc/util/ScalaClassLoader.scala index 07fe254410..d048b75599 100644 --- a/src/compiler/scala/tools/nsc/util/ScalaClassLoader.scala +++ b/src/compiler/scala/tools/nsc/util/ScalaClassLoader.scala @@ -6,26 +6,34 @@ package scala.tools.nsc package util -import java.lang.{ ClassLoader => JavaClassLoader } +import java.lang.{ ClassLoader => JClassLoader } import java.lang.reflect.{ Constructor, Modifier, Method } +import java.io.{ File => JFile } +import java.net.{ URLClassLoader => JURLClassLoader } import java.net.URL +import scala.reflect.unwrapForHandler import ScalaClassLoader._ import scala.util.control.Exception.{ catching } +// import Exceptional.unwrap -trait ScalaClassLoader extends JavaClassLoader { +trait HasClassPath { + def classPathURLs: Seq[URL] +} + +/** A wrapper around java.lang.ClassLoader to lower the annoyance + * of java reflection. + */ +trait ScalaClassLoader extends JClassLoader { /** Override to see classloader activity traced */ protected def trace: Boolean = false /** Executing an action with this classloader as context classloader */ def asContext[T](action: => T): T = { - val oldLoader = getContextLoader - try { - setContextLoader(this) - action - } - finally setContextLoader(oldLoader) + val saved = contextLoader + try { setContext(this) ; action } + finally setContext(saved) } - def setAsContext() { setContextLoader(this) } + def setAsContext() { setContext(this) } /** Load and link a class with this classloader */ def tryToLoadClass[T <: AnyRef](path: String): Option[Class[T]] = tryClass(path, false) @@ -70,68 +78,97 @@ trait ScalaClassLoader extends JavaClassLoader { val clsToRun = tryToInitializeClass(objectName) getOrElse ( throw new ClassNotFoundException(objectName) ) - val method = clsToRun.getMethod("main", classOf[Array[String]]) if (!Modifier.isStatic(method.getModifiers)) throw new NoSuchMethodException(objectName + ".main is not static") - asContext(method.invoke(null, Array(arguments.toArray: AnyRef): _*)) // !!! : AnyRef shouldn't be necessary + try asContext(method.invoke(null, Array(arguments.toArray: AnyRef): _*)) // !!! : AnyRef shouldn't be necessary + catch unwrapForHandler({ case ex => throw ex }) } + + /** A list comprised of this classloader followed by all its + * (non-null) parent classloaders, if any. + */ + def loaderChain: List[ScalaClassLoader] = this :: (getParent match { + case null => Nil + case p => p.loaderChain + }) } +/** Methods for obtaining various classloaders. + * appLoader: the application classloader. (Also called the java system classloader.) + * extLoader: the extension classloader. + * bootLoader: the boot classloader. + * contextLoader: the context classloader. + */ object ScalaClassLoader { - implicit def apply(cl: JavaClassLoader): ScalaClassLoader = { - val loader = if (cl == null) JavaClassLoader.getSystemClassLoader() else cl - new JavaClassLoader(loader) with ScalaClassLoader + /** Returns loaders which are already ScalaClassLoaders unaltered, + * and translates java.net.URLClassLoaders into scala URLClassLoaders. + * Otherwise creates a new wrapper. + */ + implicit def apply(cl: JClassLoader): ScalaClassLoader = cl match { + case cl: ScalaClassLoader => cl + case cl: JURLClassLoader => new URLClassLoader(cl.getURLs.toSeq, cl.getParent) + case _ => new JClassLoader(cl) with ScalaClassLoader + } + def contextLoader = apply(Thread.currentThread.getContextClassLoader) + def appLoader = apply(JClassLoader.getSystemClassLoader) + def extLoader = apply(appLoader.getParent) + def bootLoader = apply(null) + def contextChain = loaderChain(contextLoader) + + def pathToErasure[T: ClassManifest] = pathToClass(classManifest[T].erasure) + def pathToClass(clazz: Class[_]) = clazz.getName.replace('.', JFile.separatorChar) + ".class" + def locate[T: ClassManifest] = contextLoader getResource pathToErasure[T] + + /** Tries to guess the classpath by type matching the context classloader + * and its parents, looking for any classloaders which will reveal their + * classpath elements as urls. It it can't find any, creates a classpath + * from the supplied string. + */ + def guessClassPathString(default: String = ""): String = { + val classpathURLs = contextChain flatMap { + case x: HasClassPath => x.classPathURLs + case x: JURLClassLoader => x.getURLs.toSeq + case _ => Nil + } + if (classpathURLs.isEmpty) default + else JavaClassPath.fromURLs(classpathURLs).asClasspathString } - class URLClassLoader(urls: Seq[URL], parent: JavaClassLoader) - extends java.net.URLClassLoader(urls.toArray, parent) - with ScalaClassLoader { + def loaderChain(head: JClassLoader) = { + def loop(cl: JClassLoader): List[JClassLoader] = + if (cl == null) Nil else cl :: loop(cl.getParent) - private var classloaderURLs = urls.toList + loop(head) + } + def setContext(cl: JClassLoader) = + Thread.currentThread.setContextClassLoader(cl) + + class URLClassLoader(urls: Seq[URL], parent: JClassLoader) + extends JURLClassLoader(urls.toArray, parent) + with ScalaClassLoader + with HasClassPath { + + private var classloaderURLs: Seq[URL] = urls private def classpathString = ClassPath.fromURLs(urls: _*) + def classPathURLs: Seq[URL] = classloaderURLs + def classPath: ClassPath[_] = JavaClassPath fromURLs classPathURLs /** Override to widen to public */ override def addURL(url: URL) = { - classloaderURLs +:= url + classloaderURLs :+= url super.addURL(url) } - override def run(objectName: String, arguments: Seq[String]) { - try super.run(objectName, arguments) - catch { case x: ClassNotFoundException => - throw new ClassNotFoundException(objectName + - " (args = %s, classpath = %s)".format(arguments mkString ", ", classpathString)) - } - } override def toString = urls.mkString("URLClassLoader(\n ", "\n ", "\n)\n") } - def setContextLoader(cl: JavaClassLoader) = Thread.currentThread.setContextClassLoader(cl) - def getContextLoader() = Thread.currentThread.getContextClassLoader() - def getSystemLoader(): ScalaClassLoader = ScalaClassLoader(null) - def defaultParentClassLoader() = findExtClassLoader() - - def fromURLs(urls: Seq[URL], parent: ClassLoader = defaultParentClassLoader()): URLClassLoader = - new URLClassLoader(urls.toList, parent) + def fromURLs(urls: Seq[URL], parent: ClassLoader = null): URLClassLoader = + new URLClassLoader(urls, parent) /** True if supplied class exists in supplied path */ def classExists(urls: Seq[URL], name: String): Boolean = - (fromURLs(urls) tryToLoadClass name).isDefined - - // we cannot use the app classloader here or we get what looks to - // be classloader deadlock, but if we pass null we bypass the extension - // classloader and our extensions, so we search the hierarchy to find - // the classloader whose parent is null. Resolves bug #857. - def findExtClassLoader(): JavaClassLoader = { - def search(cl: JavaClassLoader): JavaClassLoader = { - if (cl == null) null - else if (cl.getParent == null) cl - else search(cl.getParent) - } - - search(getContextLoader()) - } + fromURLs(urls) tryToLoadClass name isDefined /** Finding what jar a clazz or instance came from */ def origin(x: Any): Option[URL] = originOfClass(x.getClass) diff --git a/src/compiler/scala/tools/util/Javap.scala b/src/compiler/scala/tools/util/Javap.scala index 04033e913d..94de5588dd 100644 --- a/src/compiler/scala/tools/util/Javap.scala +++ b/src/compiler/scala/tools/util/Javap.scala @@ -14,7 +14,7 @@ import scala.tools.nsc.io.{ File, NullPrintStream } import Javap._ class Javap( - val loader: ScalaClassLoader = ScalaClassLoader.getSystemLoader(), + val loader: ScalaClassLoader = ScalaClassLoader.appLoader, val printWriter: PrintWriter = new PrintWriter(System.out, true) ) { @@ -79,7 +79,7 @@ object Javap { val Env = "sun.tools.javap.JavapEnvironment" val Printer = "sun.tools.javap.JavapPrinter" - def isAvailable(cl: ScalaClassLoader = ScalaClassLoader.getSystemLoader()) = + def isAvailable(cl: ScalaClassLoader = ScalaClassLoader.appLoader) = cl.tryToInitializeClass[AnyRef](Env).isDefined // "documentation" diff --git a/src/compiler/scala/tools/util/SignalManager.scala b/src/compiler/scala/tools/util/SignalManager.scala index 19b5348a43..e93297386a 100644 --- a/src/compiler/scala/tools/util/SignalManager.scala +++ b/src/compiler/scala/tools/util/SignalManager.scala @@ -32,7 +32,7 @@ import scala.util.Random * }}} */ class SignalManager(classLoader: ScalaClassLoader) { - def this() = this(ScalaClassLoader.getSystemLoader) + def this() = this(ScalaClassLoader.appLoader) private val illegalArgHandler: PartialFunction[Throwable, Boolean] = { case x if unwrap(x).isInstanceOf[IllegalArgumentException] => false } diff --git a/src/partest/scala/tools/partest/nest/Worker.scala b/src/partest/scala/tools/partest/nest/Worker.scala index 45902229eb..711e3f0935 100644 --- a/src/partest/scala/tools/partest/nest/Worker.scala +++ b/src/partest/scala/tools/partest/nest/Worker.scala @@ -400,8 +400,8 @@ class Worker(val fileManager: FileManager, params: TestRunParams) extends Actor */ def runTests(files: List[File])(topcont: Map[String, Int] => Unit) { val compileMgr = new CompileManager(fileManager) - if (kind == "scalacheck") fileManager.CLASSPATH += File.pathSeparator + PathSettings.scalaCheck - + // if (kind == "scalacheck") + fileManager.CLASSPATH += File.pathSeparator + PathSettings.scalaCheck filesRemaining = files // You don't default "succeeded" to true. diff --git a/src/scalap/scala/tools/scalap/Decode.scala b/src/scalap/scala/tools/scalap/Decode.scala index b4f93bccd4..4e12075541 100644 --- a/src/scalap/scala/tools/scalap/Decode.scala +++ b/src/scalap/scala/tools/scalap/Decode.scala @@ -11,7 +11,7 @@ package scala.tools.scalap import scala.tools.scalap.scalax.rules.scalasig._ import scala.tools.nsc.util.ScalaClassLoader -import scala.tools.nsc.util.ScalaClassLoader.getSystemLoader +import scala.tools.nsc.util.ScalaClassLoader.appLoader import scala.reflect.internal.pickling.ByteCodecs import ClassFileParser.{ ConstValueIndex, Annotation } @@ -31,7 +31,7 @@ object Decode { /** Return the classfile bytes representing the scala sig classfile attribute. * This has been obsoleted by the switch to annotations. */ - def scalaSigBytes(name: String): Option[Array[Byte]] = scalaSigBytes(name, getSystemLoader()) + def scalaSigBytes(name: String): Option[Array[Byte]] = scalaSigBytes(name, appLoader) def scalaSigBytes(name: String, classLoader: ScalaClassLoader): Option[Array[Byte]] = { val bytes = classLoader.classBytes(name) val reader = new ByteArrayReader(bytes) @@ -41,7 +41,7 @@ object Decode { /** Return the bytes representing the annotation */ - def scalaSigAnnotationBytes(name: String): Option[Array[Byte]] = scalaSigAnnotationBytes(name, getSystemLoader()) + def scalaSigAnnotationBytes(name: String): Option[Array[Byte]] = scalaSigAnnotationBytes(name, appLoader) def scalaSigAnnotationBytes(name: String, classLoader: ScalaClassLoader): Option[Array[Byte]] = { val bytes = classLoader.classBytes(name) val byteCode = ByteCode(bytes) @@ -67,7 +67,7 @@ object Decode { } for { - clazz <- getSystemLoader.tryToLoadClass[AnyRef](outer) + clazz <- appLoader.tryToLoadClass[AnyRef](outer) ssig <- ScalaSigParser.parse(clazz) } yield { @@ -89,7 +89,7 @@ object Decode { */ private[scala] def typeAliases(pkg: String) = { for { - clazz <- getSystemLoader.tryToLoadClass[AnyRef](pkg + ".package") + clazz <- appLoader.tryToLoadClass[AnyRef](pkg + ".package") ssig <- ScalaSigParser.parse(clazz) } yield { |