WIP

Author: retronym

src/compiler/scala/tools/nsc/PipelineMain.scala

@@ -7,6 +7,7 @@ package scala.tools.nsc
 import java.io.File
 import java.nio.ByteBuffer
 import java.nio.file.{Files, Path, Paths}
+import java.util.Collections
 
 import javax.tools.{SimpleJavaFileObject, ToolProvider}
 
@@ -16,7 +17,7 @@ import scala.concurrent.{Await, ExecutionContext, Future, Promise}
 import scala.reflect.internal.pickling.PickleBuffer
 import scala.reflect.internal.util.FakePos
 import scala.reflect.io.{VirtualDirectory, VirtualFile}
-import scala.tools.nsc.backend.{ClassfileInfo, ScalaClass, ScalaRawClass}
+import scala.tools.nsc.backend.{ClassfileInfo, JavaPlatform, ScalaClass, ScalaRawClass}
 import scala.tools.nsc.classpath.{DirectoryClassPath, VirtualDirectoryClassPath}
 import scala.tools.nsc.io.AbstractFile
 import scala.tools.nsc.reporters.{ConsoleReporter, Reporter}
@@ -77,6 +78,7 @@ class PipelineMainClass(label: String, parallelism: Int, strategy: BuildStrategy
     }
   }
   private val allPickleData =  new java.util.concurrent.ConcurrentHashMap[Path, PickleClassPath[_]]
+  private val allParsedInfos = new java.util.concurrent.ConcurrentHashMap[AbstractFile, ClassfileInfo]
 
   def process(args: Array[String]): Boolean = {
     println(s"parallelism = $parallelism, strategy = $strategy")
@@ -358,6 +360,7 @@ class PipelineMainClass(label: String, parallelism: Int, strategy: BuildStrategy
         javaDone.completeWith(Future {
           val opts = java.util.Arrays.asList("-d", command.settings.outdir.value, "-cp", command.settings.outdir.value + File.pathSeparator + command.settings.classpath.value)
           val compileTask = ToolProvider.getSystemJavaCompiler.getTask(null, null, null, opts, null, fileManager.getJavaFileObjects(javaSources.toArray: _*))
+          compileTask.setProcessors(Collections.emptyList())
           compileTask.call()
         })
       } else {
@@ -409,10 +412,17 @@ class PipelineMainClass(label: String, parallelism: Int, strategy: BuildStrategy
           case vf: VirtualFile =>
             val iterator = replacements.iterator.flatMap(_.classInfo.get(vf))
             if (iterator.hasNext)
-              Some(iterator.next())
+              return Some(iterator.next())
             else None
           case _ => None
         }
+        allParsedInfos.get(file) match {
+          case null => None
+          case info => Some(info)
+        }
+      }
+      override def parsed(file: AbstractFile, clazz: g.ClassSymbol, info: ClassfileInfo): Unit = {
+        allParsedInfos.put(file, info)
       }
     }
     g.platform.addClassPathPlugin(plugin)

src/compiler/scala/tools/nsc/backend/Platform.scala

@@ -54,6 +54,7 @@ trait Platform {
     */
   abstract class ClassPathPlugin {
     def info(file: AbstractFile, clazz: ClassSymbol): Option[ClassfileInfo]
+    def parsed(file: AbstractFile, clazz: ClassSymbol, info: ClassfileInfo): Unit = ()
     def modifyClassPath(classPath: Seq[ClassPath]): Seq[ClassPath] = classPath
   }
 
@@ -83,6 +84,9 @@ trait Platform {
       case (None, plugin) => plugin.info(file, clazz)
     }
   }
+  final def classFileInfoParsed(file: AbstractFile, clazz: ClassSymbol, info: ClassfileInfo): Unit = if (classPathPlugins eq Nil) None else {
+    classPathPlugins.foreach(_.parsed(file, clazz, info))
+  }
 }
 
 sealed abstract class ClassfileInfo {}

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

@@ -18,7 +18,7 @@ trait AbsSettings extends scala.reflect.internal.settings.AbsSettings {
   protected def allSettings: scala.collection.Set[Setting]
 
   // settings minus internal usage settings
-  def visibleSettings = allSettings filterNot (_.isInternalOnly)
+  def visibleSettings = allSettings.iterator filterNot (_.isInternalOnly)
 
   // only settings which differ from default
   def userSetSettings = visibleSettings filterNot (_.isDefault)

src/compiler/scala/tools/nsc/symtab/classfile/ClassfileParser.scala

@@ -10,6 +10,7 @@ package classfile
 
 import java.io._
 import java.lang.Integer.toHexString
+import java.nio.ByteBuffer
 
 import scala.collection.{immutable, mutable}
 import scala.collection.mutable.{ArrayBuffer, ListBuffer}
@@ -158,26 +159,32 @@ abstract class ClassfileParser {
               isScalaRaw = true
               currentClass = TermName(className)
             case ScalaClass(className, pickle) =>
+              val pickle1 = pickle
               isScala = true
               currentClass = TermName(className)
-              if (pickle.hasArray) {
-                unpickler.unpickle(pickle.array, pickle.arrayOffset + pickle.position(), clazz, staticModule, file.name)
+              if (pickle1.hasArray) {
+                unpickler.unpickle(pickle1.array, pickle1.arrayOffset + pickle1.position(), clazz, staticModule, file.name)
               } else {
-                val array = new Array[Byte](pickle.remaining)
-                pickle.get(array)
+                val array = new Array[Byte](pickle1.remaining)
+                pickle1.get(array)
                 unpickler.unpickle(array, 0, clazz, staticModule, file.name)
               }
             case ClassBytes(data) =>
-              val array = new Array[Byte](data.remaining)
-              data.get(array)
+              val data1 = data.duplicate()
+              val array = new Array[Byte](data1.remaining)
+              data1.get(array)
               this.in = new AbstractFileReader(file, array)
+              parseHeader()
+              this.pool = newConstantPool
               parseClass()
           }
         case None =>
           this.in = new AbstractFileReader(file)
           parseHeader()
           this.pool = newConstantPool
           parseClass()
+          if (!(isScala || isScalaRaw))
+            loaders.platform.classFileInfoParsed(file, clazz, ClassBytes(ByteBuffer.wrap(in.buf)))
       }
       if (isScalaRaw && !isNothingOrNull) {
         unlinkRaw()
@@ -929,8 +936,8 @@ abstract class ClassfileParser {
               case Some(san: AnnotationInfo) =>
                 val bytes =
                   san.assocs.find({ _._1 == nme.bytes }).get._2.asInstanceOf[ScalaSigBytes].bytes
-
                 unpickler.unpickle(bytes, 0, clazz, staticModule, in.file.name)
+                loaders.platform.classFileInfoParsed(file, clazz, ScalaClass(this.currentClass.toString, ByteBuffer.wrap(bytes)))
               case None =>
                 throw new RuntimeException("Scala class file does not contain Scala annotation")
             }
@@ -1245,6 +1252,7 @@ abstract class ClassfileParser {
           in.skip(attrLen)
         case tpnme.ScalaATTR =>
           isScalaRaw = true
+          loaders.platform.classFileInfoParsed(file, clazz, ScalaRawClass(this.currentClass.toString))
         case tpnme.InnerClassesATTR if !isScala =>
           val entries = u2
           for (i <- 0 until entries) {