Upgrade to sbt 1

.drone.yml

@@ -23,39 +23,39 @@ pipeline:
   # We run tests in parallel. Tests run in a copy of the working directory to avoid conflict
   test:
     group: test
-    image: lampepfl/dotty:2018-01-17
+    image: lampepfl/dotty:2018-04-10
     commands:
       - cp -R . /tmp/1/ && cd /tmp/1/
       - ./project/scripts/sbt ";compile ;test"
       - ./project/scripts/cmdTests
 
   test_bootstrapped:
     group: test
-    image: lampepfl/dotty:2018-01-17
+    image: lampepfl/dotty:2018-04-10
     commands:
       - cp -R . /tmp/2/ && cd /tmp/2/
       - ./project/scripts/sbt ";dotty-bootstrapped/compile ;dotty-bootstrapped/test"
 
   test_optimised:
     group: test
-    image: lampepfl/dotty:2018-01-17
+    image: lampepfl/dotty:2018-04-10
     commands:
       - cp -R . /tmp/3/ && cd /tmp/3/
       - ./project/scripts/sbt dotty-optimised/test
 
   test_sbt:
     group: test
-    image: lampepfl/dotty:2018-01-17
+    image: lampepfl/dotty:2018-04-10
     commands:
       - cp -R . /tmp/4/ && cd /tmp/4/
       - ./project/scripts/sbt sbt-dotty/scripted
-    when:
-      # sbt scripted tests are slow and don't run on PRs
-      event: [ tag, deployment ]
+    # when:
+    #   # sbt scripted tests are slow and only run on nightly or deployment
+    #   event: [ tag, deployment ]
 
   # DOCUMENTATION:
   documentation:
-    image: lampepfl/dotty:2018-01-17
+    image: lampepfl/dotty:2018-04-10
     commands:
       - ./project/scripts/genDocs
     secrets: [ bot_pass ]
@@ -67,7 +67,7 @@ pipeline:
   # PUBLISHING:
   # Publishing expect NIGHTLYBUILD or RELEASEBUILD to be set. See dottyVersion in Build.scala
   publish_nightly:
-    image: lampepfl/dotty:2018-01-17
+    image: lampepfl/dotty:2018-04-10
     environment:
       - NIGHTLYBUILD=yes
     commands:
@@ -78,7 +78,7 @@ pipeline:
       environment: nightly
 
   publish_release:
-    image: lampepfl/dotty:2018-01-17
+    image: lampepfl/dotty:2018-04-10
     environment:
       - RELEASEBUILD=yes
     commands:
@@ -102,7 +102,7 @@ pipeline:
       event: tag
 
   publish_sbt_release:
-    image: lampepfl/dotty:2018-01-17
+    image: lampepfl/dotty:2018-04-10
     environment:
       - RELEASEBUILD=yes
     commands:

.gitignore

@@ -18,6 +18,7 @@ project/local-plugins.sbt
 .history
 .ensime
 .ensime_cache/
+.sbt-scripted/
 
 # npm
 node_modules

build.sbt

@@ -14,7 +14,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

@@ -13,11 +13,13 @@ import scala.tools.nsc.backend.jvm._
 import dotty.tools.dotc
 import dotty.tools.dotc.backend.jvm.DottyPrimitives
 import dotty.tools.dotc.transform.Erasure
+import dotty.tools.dotc.transform.SymUtils._
 import dotty.tools.dotc.interfaces
 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._
@@ -113,14 +115,16 @@ class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInter
 
     /* ---------------- q2 ---------------- */
 
-    case class Item2(arrivalPos:   Int,
-                     mirror:       asm.tree.ClassNode,
-                     plain:        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) {
       def isPoison = { arrivalPos == Int.MaxValue }
     }
 
-    private val poison2 = Item2(Int.MaxValue, null, null, null)
+    private val poison2 = Item2(Int.MaxValue, null, null)
     private val q2 = new _root_.java.util.LinkedList[Item2]
 
     /* ---------------- q3 ---------------- */
@@ -134,13 +138,13 @@ 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,
-                     outFolder:  scala.tools.nsc.io.AbstractFile) {
+                     plain:      SubItem3) {
 
       def isPoison  = { arrivalPos == Int.MaxValue }
     }
@@ -151,15 +155,31 @@ class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInter
         else 1
       }
     }
-    private val poison3 = Item3(Int.MaxValue, null, null, null)
+    private val poison3 = Item3(Int.MaxValue, null, null)
     private val q3 = new java.util.PriorityQueue[Item3](1000, i3comparator)
 
     /*
      *  Pipeline that takes ClassDefs from queue-1, lowers them into an intermediate form, placing them on queue-2
      */
     class Worker1(needsOutFolder: Boolean) {
 
-      val caseInsensitively = scala.collection.mutable.HashMap.empty[String, Symbol]
+      private val lowerCaseNames = mutable.HashMap.empty[String, Symbol]
+      private def checkForCaseConflict(javaClassName: String, classSymbol: Symbol) = {
+        val lowerCaseName = javaClassName.toLowerCase
+        lowerCaseNames.get(lowerCaseName) match {
+          case None =>
+            lowerCaseNames.put(lowerCaseName, classSymbol)
+          case Some(dupClassSym) =>
+            // Order is not deterministic so we enforce lexicographic order between the duplicates for error-reporting
+            val (cl1, cl2) =
+              if (classSymbol.effectiveName.toString < dupClassSym.effectiveName.toString) (classSymbol, dupClassSym)
+              else (dupClassSym, classSymbol)
+            ctx.atPhase(ctx.typerPhase) { implicit ctx =>
+              ctx.warning(s"${cl1.show} differs only in case from ${cl2.showLocated}. " +
+                "Such classes will overwrite one another on case-insensitive filesystems.", cl1.pos)
+            }
+        }
+      }
 
       def run(): Unit = {
         while (true) {
@@ -189,30 +209,6 @@ class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInter
         val Item1(arrivalPos, cd, cunit) = item
         val claszSymbol = cd.symbol
 
-        // GenASM checks this before classfiles are emitted, https://github.com/scala/scala/commit/e4d1d930693ac75d8eb64c2c3c69f2fc22bec739
-        def checkName(claszSymbol: Symbol): Unit = {
-          val lowercaseJavaClassName = claszSymbol.effectiveName.toString.toLowerCase
-          caseInsensitively.get(lowercaseJavaClassName) match {
-            case None =>
-              caseInsensitively.put(lowercaseJavaClassName, claszSymbol)
-            case Some(dupClassSym) =>
-              if (claszSymbol.effectiveName.toString != dupClassSym.effectiveName.toString) {
-                // Order is not deterministic so we enforce lexicographic order between the duplicates for error-reporting
-                val (cl1, cl2) =
-                  if (claszSymbol.effectiveName.toString < dupClassSym.effectiveName.toString) (claszSymbol, dupClassSym)
-                  else (dupClassSym, claszSymbol)
-                ctx.warning(s"Class ${cl1.effectiveName} differs only in case from ${cl2.effectiveName}. " +
-                  "Such classes will overwrite one another on case-insensitive filesystems.", cl1.pos)
-              }
-          }
-        }
-        checkName(claszSymbol)
-        if (int.symHelper(claszSymbol).isModuleClass) {
-          val companionModule = claszSymbol.companionModule
-          if (int.symHelper(companionModule.owner).isPackageClass)
-            checkName(companionModule)
-        }
-
         // -------------- mirror class, if needed --------------
         val mirrorC =
           if (int.symHelper(claszSymbol).isTopLevelModuleClass) {
@@ -253,12 +249,50 @@ class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInter
           }
 
 
+        // ----------- create files
+
+        val classNodes = List(mirrorC, plainC)
+        val classFiles = classNodes.map(cls =>
+          if (outF != null && cls != null) {
+            try {
+              checkForCaseConflict(cls.name, claszSymbol)
+              getFileForClassfile(outF, cls.name, ".class")
+            } catch {
+              case e: FileConflictException =>
+                ctx.error(s"error writing ${cls.name}: ${e.getMessage}")
+                null
+            }
+          } else null
+        )
+
+        // ----------- compiler and sbt's callbacks
+
+        val (fullClassName, isLocal) = ctx.atPhase(ctx.sbtExtractDependenciesPhase) { implicit ctx =>
+          (ExtractDependencies.classNameAsString(claszSymbol), claszSymbol.isLocal)
+        }
+
+        for ((cls, clsFile) <- classNodes.zip(classFiles)) {
+          if (cls != null) {
+            val className = cls.name.replace('/', '.')
+            if (ctx.compilerCallback != null)
+              ctx.compilerCallback.onClassGenerated(sourceFile, convertAbstractFile(clsFile), className)
+            if (ctx.sbtCallback != null) {
+              if (isLocal)
+                ctx.sbtCallback.generatedLocalClass(sourceFile.jfile.orElse(null), clsFile.file)
+              else {
+                ctx.sbtCallback.generatedNonLocalClass(sourceFile.jfile.orElse(null), clsFile.file,
+                  className, fullClassName)
+              }
+            }
+          }
+        }
+
         // ----------- hand over to pipeline-2
 
         val item2 =
           Item2(arrivalPos,
-            mirrorC, plainC,
-            outF)
+            SubItem2(mirrorC, classFiles(0)),
+            SubItem2(plainC, classFiles(1)))
 
         q2 add item2 // at the very end of this method so that no Worker2 thread starts mutating before we're done.
 
@@ -288,12 +322,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}")
             }
           }
         }
@@ -307,18 +341,17 @@ class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInter
           cw.toByteArray
         }
 
-        val Item2(arrivalPos, mirror, plain, outFolder) = item
+        val Item2(arrivalPos, SubItem2(mirror, mirrorFile), SubItem2(plain, plainFile)) = item
 
-        val mirrorC = if (mirror == null) null else SubItem3(mirror.name, getByteArray(mirror))
-        val plainC  = SubItem3(plain.name, getByteArray(plain))
+        val mirrorC = if (mirror == null) null else SubItem3(mirror.name, getByteArray(mirror), mirrorFile)
+        val plainC  = SubItem3(plain.name, getByteArray(plain), plainFile)
 
         if (AsmUtils.traceSerializedClassEnabled && plain.name.contains(AsmUtils.traceSerializedClassPattern)) {
           if (mirrorC != null) AsmUtils.traceClass(mirrorC.jclassBytes)
           AsmUtils.traceClass(plainC.jclassBytes)
         }
 
-        q3 add Item3(arrivalPos, mirrorC, plainC, outFolder)
-
+        q3 add Item3(arrivalPos, mirrorC, plainC)
       }
 
     } // end of class BCodePhase.Worker2
@@ -416,25 +449,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)
         }
       }
 
@@ -447,9 +465,8 @@ 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.mirror)
+          sendToDisk(item.plain)
           expected += 1
         }
       }

compiler/src/dotty/tools/dotc/config/JavaPlatform.scala

@@ -21,19 +21,12 @@ class JavaPlatform extends Platform {
   }
 
   // The given symbol is a method with the right name and signature to be a runnable java program.
-  def isJavaMainMethod(sym: SymDenotation)(implicit ctx: Context) =
+  def isMainMethod(sym: SymDenotation)(implicit ctx: Context) =
     (sym.name == nme.main) && (sym.info match {
       case MethodTpe(_, defn.ArrayOf(el) :: Nil, restpe) => el =:= defn.StringType && (restpe isRef defn.UnitClass)
       case _ => false
     })
 
-  // The given class has a main method.
-  def hasJavaMainMethod(sym: Symbol)(implicit ctx: Context): Boolean =
-    (sym.info member nme.main).hasAltWith {
-      case x: SymDenotation => isJavaMainMethod(x)
-      case _ => false
-    }
-
   /** Update classpath with a substituted subentry */
   def updateClassPath(subst: Map[ClassPath, ClassPath]): Unit = currentClassPath.get match {
     case AggregateClassPath(entries) =>

compiler/src/dotty/tools/dotc/config/Platform.scala

@@ -10,6 +10,8 @@ package config
 import io.{ClassPath, AbstractFile}
 import core.Contexts._, core.Symbols._
 import core.SymbolLoader
+import core.SymDenotations.SymDenotation
+import core.StdNames.nme
 
 /** The platform dependent pieces of Global.
  */
@@ -35,5 +37,15 @@ abstract class Platform {
 
   /** Create a new class loader to load class file `bin` */
   def newClassLoader(bin: AbstractFile)(implicit ctx: Context): SymbolLoader
+
+  /** The given symbol is a method with the right name and signature to be a runnable program. */
+  def isMainMethod(sym: SymDenotation)(implicit ctx: Context): Boolean
+
+  /** The given class has a main method. */
+  final def hasMainMethod(sym: Symbol)(implicit ctx: Context): Boolean =
+    sym.info.member(nme.main).hasAltWith {
+      case x: SymDenotation => isMainMethod(x)
+      case _ => false
+    }
 }
 

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

@@ -422,7 +422,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))
     }