Upgrade to sbt 1

.drone.yml

@@ -41,15 +41,25 @@ pipeline:
       - cp -R . /tmp/3/ && cd /tmp/3/
       - ./project/scripts/sbt dotty-optimised/testAll
 
-  test_sbt:
+  test_sbt_1of2:
     group: test
     image: lampepfl/dotty:2017-10-20
     commands:
       - cp -R . /tmp/4/ && cd /tmp/4/
-      - ./project/scripts/sbt sbt-dotty/scripted
-    when:
+      - ./project/scripts/sbt "sbt-dotty/scripted compilerReporter/* discovery/* sbt-dotty/* source-dependencies/*1of2"
+    # when:
       # sbt scripted tests are slow and don't run on PRs
-      event: [ push, tag, deployment ]
+      # event: [ push, tag, deployment ]
+
+  test_sbt_2of2:
+    group: test
+    image: lampepfl/dotty:2017-10-20
+    commands:
+      - cp -R . /tmp/5/ && cd /tmp/5/
+      - ./project/scripts/sbt "sbt-dotty/scripted source-dependencies/*2of2"
+    # when:
+      # sbt scripted tests are slow and don't run on PRs
+      # event: [ push, tag, deployment ]
 
   # DOCUMENTATION:
   documentation:

build.sbt

@@ -15,7 +15,6 @@ val `dotty-library-optimised` = Build.`dotty-library-optimised`
 val `dotty-sbt-bridge` = Build.`dotty-sbt-bridge`
 val `dotty-sbt-bridge-bootstrapped` = Build.`dotty-sbt-bridge-bootstrapped`
 val `dotty-language-server` = Build.`dotty-language-server`
-val sjsSandbox = Build.sjsSandbox
 val `dotty-bench` = Build.`dotty-bench`
 val `dotty-bench-bootstrapped` = Build.`dotty-bench-bootstrapped`
 val `dotty-bench-optimised` = Build.`dotty-bench-optimised`

compiler/src/dotty/tools/backend/jvm/GenBCode.scala

@@ -17,6 +17,7 @@ import java.util.Optional
 
 import scala.reflect.ClassTag
 import dotty.tools.dotc.core._
+import dotty.tools.dotc.sbt.ExtractDependencies
 import Periods._
 import SymDenotations._
 import Contexts._
@@ -91,15 +92,17 @@ class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInter
 
     /* ---------------- q2 ---------------- */
 
-    case class Item2(arrivalPos:   Int,
-                     mirror:       asm.tree.ClassNode,
-                     plain:        asm.tree.ClassNode,
-                     bean:         asm.tree.ClassNode,
-                     outFolder:    scala.tools.nsc.io.AbstractFile) {
+    case class SubItem2(classNode: asm.tree.ClassNode,
+                        file:      scala.tools.nsc.io.AbstractFile)
+
+    case class Item2(arrivalPos: Int,
+                     mirror:     SubItem2,
+                     plain:      SubItem2,
+                     bean:       SubItem2) {
       def isPoison = { arrivalPos == Int.MaxValue }
     }
 
-    private val poison2 = Item2(Int.MaxValue, null, null, null, null)
+    private val poison2 = Item2(Int.MaxValue, null, null, null)
     private val q2 = new _root_.java.util.LinkedList[Item2]
 
     /* ---------------- q3 ---------------- */
@@ -113,14 +116,14 @@ class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInter
      */
     case class SubItem3(
                          jclassName:  String,
-                         jclassBytes: Array[Byte]
+                         jclassBytes: Array[Byte],
+                         jclassFile:  scala.tools.nsc.io.AbstractFile
                          )
 
     case class Item3(arrivalPos: Int,
                      mirror:     SubItem3,
                      plain:      SubItem3,
-                     bean:       SubItem3,
-                     outFolder:  scala.tools.nsc.io.AbstractFile) {
+                     bean:       SubItem3) {
 
       def isPoison  = { arrivalPos == Int.MaxValue }
     }
@@ -131,7 +134,7 @@ class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInter
         else 1
       }
     }
-    private val poison3 = Item3(Int.MaxValue, null, null, null, null)
+    private val poison3 = Item3(Int.MaxValue, null, null, null)
     private val q3 = new java.util.PriorityQueue[Item3](1000, i3comparator)
 
     /*
@@ -228,12 +231,52 @@ class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInter
             )
           } else null
 
+        // ----------- create files
+
+        val classNodes = List(mirrorC, plainC, beanC)
+        val classFiles = classNodes.map(cls =>
+          if (outF != null && cls != null) {
+            try {
+              getFileForClassfile(outF, cls.name, ".class")
+            } catch {
+              case e: FileConflictException =>
+                ctx.error(s"error writing ${cls.name}: ${e.getMessage}")
+                null
+            }
+          } else null
+        )
+
+        // ----------- sbt's callbacks
+
+        val fullClassName = ctx.atPhase(ctx.typerPhase) { implicit ctx =>
+          ExtractDependencies.extractedName(claszSymbol)
+        }
+        val isLocal = fullClassName.contains("_$")
+
+        for ((cls, clsFile) <- classNodes.zip(classFiles)) {
+          if (cls != null) {
+            if (ctx.compilerCallback != null)
+              ctx.compilerCallback.onClassGenerated(sourceFile, convertAbstractFile(clsFile), fullClassName)
+            if (ctx.sbtCallback != null) {
+              // ctx.sbtCallback.generatedClass(sourceFile.jfile.orElse(null), clsFile.file, fullClassName)
+              // TODO: Check
+              if (isLocal)
+                ctx.sbtCallback.generatedLocalClass(sourceFile.jfile.orElse(null), clsFile.file)
+              else {
+                ctx.sbtCallback.generatedNonLocalClass(sourceFile.jfile.orElse(null), clsFile.file,
+                  cls.name, fullClassName)
+              }
+            }
+          }
+        }
+
         // ----------- hand over to pipeline-2
 
         val item2 =
           Item2(arrivalPos,
-            mirrorC, plainC, beanC,
-            outF)
+            SubItem2(mirrorC, classFiles(0)),
+            SubItem2(plainC, classFiles(1)),
+            SubItem2(beanC, classFiles(2)))
 
         q2 add item2 // at the very end of this method so that no Worker2 thread starts mutating before we're done.
 
@@ -263,12 +306,12 @@ class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInter
           }
           else {
             try {
-              localOptimizations(item.plain)
+              localOptimizations(item.plain.classNode)
               addToQ3(item)
             } catch {
               case ex: Throwable =>
                 ex.printStackTrace()
-                ctx.error(s"Error while emitting ${item.plain.name}\n${ex.getMessage}")
+                ctx.error(s"Error while emitting ${item.plain.classNode.name}\n${ex.getMessage}")
             }
           }
         }
@@ -282,19 +325,22 @@ class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInter
           cw.toByteArray
         }
 
-        val Item2(arrivalPos, mirror, plain, bean, outFolder) = item
+        val Item2(arrivalPos,
+                  SubItem2(mirror, mirrorFile),
+                  SubItem2(plain, plainFile),
+                  SubItem2(bean, beanFile)) = item
 
-        val mirrorC = if (mirror == null) null else SubItem3(mirror.name, getByteArray(mirror))
-        val plainC  = SubItem3(plain.name, getByteArray(plain))
-        val beanC   = if (bean == null)   null else SubItem3(bean.name, getByteArray(bean))
+        val mirrorC = if (mirror == null) null else SubItem3(mirror.name, getByteArray(mirror), mirrorFile)
+        val plainC  = SubItem3(plain.name, getByteArray(plain), plainFile)
+        val beanC   = if (bean == null)   null else SubItem3(bean.name, getByteArray(bean), beanFile)
 
         if (AsmUtils.traceSerializedClassEnabled && plain.name.contains(AsmUtils.traceSerializedClassPattern)) {
           if (mirrorC != null) AsmUtils.traceClass(mirrorC.jclassBytes)
           AsmUtils.traceClass(plainC.jclassBytes)
           if (beanC != null) AsmUtils.traceClass(beanC.jclassBytes)
         }
 
-        q3 add Item3(arrivalPos, mirrorC, plainC, beanC, outFolder)
+        q3 add Item3(arrivalPos, mirrorC, plainC, beanC)
 
       }
 
@@ -394,25 +440,10 @@ class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInter
     /* Pipeline that writes classfile representations to disk. */
     private def drainQ3() = {
 
-      def sendToDisk(cfr: SubItem3, outFolder: scala.tools.nsc.io.AbstractFile): Unit = {
+      def sendToDisk(cfr: SubItem3): Unit = {
         if (cfr != null){
-          val SubItem3(jclassName, jclassBytes) = cfr
-          try {
-            val outFile =
-              if (outFolder == null) null
-              else getFileForClassfile(outFolder, jclassName, ".class")
-            bytecodeWriter.writeClass(jclassName, jclassName, jclassBytes, outFile)
-
-            val className = jclassName.replace('/', '.')
-            if (ctx.compilerCallback != null)
-              ctx.compilerCallback.onClassGenerated(sourceFile, convertAbstractFile(outFile), className)
-            if (ctx.sbtCallback != null)
-              ctx.sbtCallback.generatedClass(sourceFile.jfile.orElse(null), outFile.file, className)
-          }
-          catch {
-            case e: FileConflictException =>
-              ctx.error(s"error writing $jclassName: ${e.getMessage}")
-          }
+          val SubItem3(jclassName, jclassBytes, jclassFile) = cfr
+          bytecodeWriter.writeClass(jclassName, jclassName, jclassBytes, jclassFile)
         }
       }
 
@@ -425,10 +456,9 @@ class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInter
         moreComing   = !incoming.isPoison
         if (moreComing) {
           val item = incoming
-          val outFolder = item.outFolder
-          sendToDisk(item.mirror, outFolder)
-          sendToDisk(item.plain,  outFolder)
-          sendToDisk(item.bean,   outFolder)
+          sendToDisk(item.mirror)
+          sendToDisk(item.plain)
+          sendToDisk(item.bean)
           expected += 1
         }
       }

compiler/src/dotty/tools/dotc/core/Names.scala

@@ -424,7 +424,8 @@ object Names {
               "dotty$tools$dotc$core$NameOps$NameDecorator$$functionArityFor$extension",
               "dotty$tools$dotc$typer$Checking$CheckNonCyclicMap$$apply",
               "$plus$plus",
-              "readConstant")
+              "readConstant",
+              "extractedName")
             .contains(elem.getMethodName))
     }
 

compiler/src/dotty/tools/dotc/core/SymDenotations.scala

@@ -11,6 +11,7 @@ import collection.BitSet
 import dotty.tools.io.AbstractFile
 import Decorators.SymbolIteratorDecorator
 import ast._
+import ast.Trees._
 import annotation.tailrec
 import CheckRealizable._
 import util.SimpleIdentityMap
@@ -334,6 +335,14 @@ object SymDenotations {
       case Nil => Nil
     }
 
+    final def children(implicit ctx: Context): List[Symbol] =
+      this.annotations.filter(_.symbol == ctx.definitions.ChildAnnot).map { annot =>
+        // refer to definition of Annotation.makeChild
+        annot.tree match {
+          case Apply(TypeApply(_, List(tpTree)), _) => tpTree.symbol
+        }
+      }
+
     /** The denotation is completed: info is not a lazy type and attributes have defined values */
     final def isCompleted: Boolean = !myInfo.isInstanceOf[LazyType]
 
@@ -919,13 +928,16 @@ object SymDenotations {
      */
     final def topLevelClass(implicit ctx: Context): Symbol = {
       def topLevel(d: SymDenotation): Symbol = {
-        if (d.isEffectiveRoot || (d is PackageClass) || (d.owner is PackageClass)) d.symbol
+        if (d.isTopLevelClass) d.symbol
         else topLevel(d.owner)
       }
       val sym = topLevel(this)
       if (sym.isClass) sym else sym.moduleClass
     }
 
+    final def isTopLevelClass(implicit ctx: Context): Boolean =
+      this.isEffectiveRoot || (this is PackageClass) || (this.owner is PackageClass)
+
     /** The package class containing this denotation */
     final def enclosingPackageClass(implicit ctx: Context): Symbol =
       if (this is PackageClass) symbol else owner.enclosingPackageClass