Merge branch 'master' into fix-i3050

Author: biboudis

.drone.yml

@@ -1,11 +1,11 @@
 pipeline:
   test:
-    image: lampepfl/dotty:2017-08-30
+    image: lampepfl/dotty:2017-09-05
     commands:
       - ./project/scripts/sbt "${CI_TEST}"
 
   publish_nightly:
-    image: lampepfl/dotty:2017-08-30
+    image: lampepfl/dotty:2017-09-05
     environment:
       - NIGHTLYBUILD=yes
     commands:
@@ -20,7 +20,7 @@ pipeline:
       environment: nightly
 
   publish_release:
-    image: lampepfl/dotty:2017-08-30
+    image: lampepfl/dotty:2017-09-05
     environment:
       - RELEASEBUILD=yes
     commands:
@@ -35,7 +35,7 @@ pipeline:
       environment: release
 
   publish_sbt_release:
-    image: lampepfl/dotty:2017-08-30
+    image: lampepfl/dotty:2017-09-05
     environment:
       - RELEASEBUILD=yes
     commands:
@@ -48,7 +48,7 @@ pipeline:
       environment: sbt_release
 
   documentation:
-    image: lampepfl/dotty:2017-08-30
+    image: lampepfl/dotty:2017-09-05
     commands:
       - ./project/scripts/genDocs "${CI_PUBLISH}" "$BOT_PASS"
     secrets: [ bot_pass ]

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -100,7 +100,8 @@ class Compiler {
            new ElimStaticThis,      // Replace `this` references to static objects by global identifiers
            new Flatten,             // Lift all inner classes to package scope
            new RestoreScopes),      // Repair scopes rendered invalid by moving definitions in prior phases of the group
-      List(new TransformWildcards,  // Replace wildcards with default values
+      List(new RenameLifted,        // Renames lifted classes to local numbering scheme
+           new TransformWildcards,  // Replace wildcards with default values
            new MoveStatics,         // Move static methods to companion classes
            new ExpandPrivate,       // Widen private definitions accessed from nested classes
            new SelectStatic,        // get rid of selects that would be compiled into GetStatic

compiler/src/dotty/tools/dotc/MissingCoreLibraryException.scala

@@ -0,0 +1,9 @@
+package dotty.tools.dotc
+
+import dotty.tools.FatalError
+
+class MissingCoreLibraryException(rootPackage: String) extends FatalError(
+  s"""Could not find package $rootPackage from compiler core libraries.
+     |Make sure the compiler core libraries are on the classpath.
+   """.stripMargin
+)

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -503,7 +503,7 @@ object desugar {
         companionDefs(anyRef, companionMeths)
       else if (isValueClass) {
         constr0.vparamss match {
-          case List(_ :: Nil) => companionDefs(anyRef, Nil)
+          case (_ :: Nil) :: _ => companionDefs(anyRef, Nil)
           case _ => Nil // error will be emitted in typer
         }
       }

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

@@ -112,11 +112,12 @@ object Decorators {
         else x1 :: xs1
       }
 
-    def foldRightBN[U](z: => U)(op: (T, => U) => U): U = xs.reverse.foldLeftBN(z)(op)
-
-    @tailrec final def foldLeftBN[U](z: => U)(op: (T, => U) => U): U = xs match {
-      case Nil => z
-      case x :: xs1 => xs1.foldLeftBN(op(x, z))(op)
+    def foldRightBN[U](z: => U)(op: (T, => U) => U): U = {
+      @tailrec def foldLeftBN(xs: List[T], acc: => U): U = xs match {
+        case x :: xs1 => foldLeftBN(xs1, op(x, acc))
+        case Nil => acc
+      }
+      foldLeftBN(xs.reverse, z)
     }
 
     final def hasSameLengthAs[U](ys: List[U]): Boolean = {

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

@@ -212,7 +212,7 @@ class Definitions {
    *  in `scalaShadowing` so they don't clash with the same-named `scala`
    *  members at runtime.
    */
-  lazy val ScalaShadowingPackageVal = ctx.requiredPackage("scalaShadowing")
+  lazy val ScalaShadowingPackageVal = ctx.requiredPackage(nme.scalaShadowing)
   lazy val ScalaShadowingPackageClass = ScalaShadowingPackageVal.moduleClass.asClass
 
   /** Note: We cannot have same named methods defined in Object and Any (and AnyVal, for that matter)

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

@@ -1192,14 +1192,23 @@ object Denotations {
     def staticRef(path: Name, generateStubs: Boolean = true, isPackage: Boolean = false)(implicit ctx: Context): Denotation = {
       def select(prefix: Denotation, selector: Name): Denotation = {
         val owner = prefix.disambiguate(_.info.isParameterless)
+        def isPackageFromCoreLibMissing: Boolean = {
+          owner.symbol == defn.RootClass &&
+          (
+            selector == nme.scala_ || // if the scala package is missing, the stdlib must be missing
+            selector == nme.scalaShadowing // if the scalaShadowing package is missing, the dotty library must be missing
+          )
+        }
         if (owner.exists) {
           val result = if (isPackage) owner.info.decl(selector) else owner.info.member(selector)
           if (result.exists) result
           else {
             val alt =
               if (generateStubs) missingHook(owner.symbol.moduleClass, selector)
               else NoSymbol
-            if (alt.exists) alt.denot else MissingRef(owner, selector)
+            if (alt.exists) alt.denot
+            else if (isPackageFromCoreLibMissing) throw new MissingCoreLibraryException(selector.toString)
+            else MissingRef(owner, selector)
           }
         }
         else owner

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

@@ -491,6 +491,7 @@ object StdNames {
     val runtimeMirror: N        = "runtimeMirror"
     val sameElements: N         = "sameElements"
     val scala_ : N              = "scala"
+    val scalaShadowing : N      = "scalaShadowing"
     val selectDynamic: N        = "selectDynamic"
     val selectDynamicMethod: N  = "selectDynamicMethod"
     val selectOverloadedMethod: N = "selectOverloadedMethod"

compiler/src/dotty/tools/dotc/parsing/JavaTokens.scala

@@ -6,7 +6,7 @@ import collection.immutable.BitSet
 
 object JavaTokens extends TokensCommon {
   final val minToken = EMPTY
-  final val maxToken = DOUBLE
+  final def maxToken = DOUBLE
 
   final val javaOnlyKeywords = tokenRange(INSTANCEOF, ASSERT)
   final val sharedKeywords = BitSet( IF, FOR, ELSE, THIS, NULL, NEW, SUPER, ABSTRACT, FINAL, PRIVATE, PROTECTED,

compiler/src/dotty/tools/dotc/parsing/Tokens.scala

@@ -6,7 +6,7 @@ import collection.immutable.BitSet
 import core.Decorators._
 
 abstract class TokensCommon {
-  val maxToken: Int
+  def maxToken: Int
 
   type Token = Int
   type TokenSet = BitSet
@@ -145,7 +145,7 @@ abstract class TokensCommon {
 
 object Tokens extends TokensCommon {
   final val minToken = EMPTY
-  final val maxToken = XMLSTART
+  final def maxToken = XMLSTART
 
   final val INTERPOLATIONID = 10;  enter(INTERPOLATIONID, "string interpolator")
   final val SYMBOLLIT = 11;        enter(SYMBOLLIT, "symbol literal") // TODO: deprecate

compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala

@@ -1636,9 +1636,9 @@ object messages {
           |"""
   }
 
-  case class ValueClassNeedsExactlyOneValParam(valueClass: Symbol)(implicit ctx: Context)
+  case class ValueClassNeedsOneValParam(valueClass: Symbol)(implicit ctx: Context)
     extends Message(ValueClassNeedsExactlyOneValParamID) {
-    val msg = hl"""value class needs to have exactly one ${"val"} parameter"""
+    val msg = hl"""value class needs one ${"val"} parameter"""
     val kind = "Syntax"
     val explanation = ""
   }

compiler/src/dotty/tools/dotc/transform/Constructors.scala

@@ -129,7 +129,7 @@ class Constructors extends MiniPhaseTransform with IdentityDenotTransformer { th
     // Produce aligned accessors and constructor parameters. We have to adjust
     // for any outer parameters, which are last in the sequence of original
     // parameter accessors but come first in the constructor parameter list.
-    val accessors = cls.paramAccessors.filterNot(_.isSetter)
+    val accessors = cls.paramAccessors.filterNot(x => x.isSetter || x.info.resultType.classSymbol == defn.ErasedPhantomClass)
     val vparamsWithOuterLast = vparams match {
       case vparam :: rest if vparam.name == nme.OUTER => rest ::: vparam :: Nil
       case _ => vparams

compiler/src/dotty/tools/dotc/transform/Erasure.scala

@@ -432,7 +432,8 @@ object Erasure {
         }
       }
 
-      if (tree.symbol eq defn.Phantom_assume) PhantomErasure.erasedAssume
+      if ((origSym eq defn.Phantom_assume) || (origSym.is(Flags.ParamAccessor) && wasPhantom(pt)))
+        PhantomErasure.erasedAssume
       else recur(typed(tree.qualifier, AnySelectionProto))
     }
 

compiler/src/dotty/tools/dotc/transform/RenameLifted.scala

@@ -0,0 +1,46 @@
+package dotty.tools.dotc.transform
+
+import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.core.Decorators._
+import dotty.tools.dotc.core.DenotTransformers.SymTransformer
+import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.NameKinds._
+import dotty.tools.dotc.core.Names._
+import dotty.tools.dotc.core.Phases
+import dotty.tools.dotc.core.SymDenotations.SymDenotation
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.transform.TreeTransforms.MiniPhaseTransform
+
+/** Renames lifted classes to local numbering scheme */
+class RenameLifted extends MiniPhaseTransform with SymTransformer { thisTransformer =>
+
+  override def phaseName = "renameLifted"
+
+  override def runsAfterGroupsOf: Set[Class[_ <: Phases.Phase]] = Set(classOf[RestoreScopes])
+
+  def transformSym(ref: SymDenotation)(implicit ctx: Context): SymDenotation =
+    if (needsRefresh(ref.symbol)) ref.copySymDenotation(name = refreshedName(ref.symbol))
+    else ref
+
+  /** If the name of the symbol with a unique name needs to be refreshed
+   *    - if it is a lifted class
+   *    - if it is a lifted method
+   */
+  private def needsRefresh(sym: Symbol)(implicit ctx: Context): Boolean =
+    (sym.isClass || sym.is(Private | Method | JavaStatic)) && sym.name.is(UniqueName)
+
+  /** Refreshes the number of the name based on the full name of the symbol */
+  private def refreshedName(sym: Symbol)(implicit ctx: Context): Name = {
+    def rewriteUnique: PartialFunction[Name, Name] = {
+      case name: DerivedName if name.info.kind == UniqueName =>
+        val fullName = (sym.owner.fullName.toString + name.underlying).toTermName
+        val freshName = UniqueName.fresh(fullName)
+        val info = freshName.asInstanceOf[DerivedName].info
+        DerivedName(name.underlying.rewrite(rewriteUnique), info)
+      case DerivedName(underlying, info: QualifiedInfo) =>
+        underlying.rewrite(rewriteUnique).derived(info)
+    }
+
+    sym.name.rewrite(rewriteUnique)
+  }
+}

compiler/src/dotty/tools/dotc/transform/SyntheticMethods.scala

@@ -159,8 +159,8 @@ class SyntheticMethods(thisTransformer: DenotTransformer) {
       val thatAsClazz = ctx.newSymbol(ctx.owner, nme.x_0, Synthetic, clazzType, coord = ctx.owner.pos) // x$0
       def wildcardAscription(tp: Type) = Typed(Underscore(tp), TypeTree(tp))
       val pattern = Bind(thatAsClazz, wildcardAscription(clazzType)) // x$0 @ (_: C)
-      val comparisons = accessors map (accessor =>
-        This(clazz).select(accessor).select(defn.Any_==).appliedTo(ref(thatAsClazz).select(accessor)))
+      val comparisons = accessors collect { case accessor if !accessor.info.isPhantom =>
+        This(clazz).select(accessor).select(defn.Any_==).appliedTo(ref(thatAsClazz).select(accessor)) }
       val rhs = // this.x == this$0.x && this.y == x$0.y
         if (comparisons.isEmpty) Literal(Constant(true)) else comparisons.reduceLeft(_ and _)
       val matchingCase = CaseDef(pattern, EmptyTree, rhs) // case x$0 @ (_: C) => this.x == this$0.x && this.y == x$0.y
@@ -186,7 +186,8 @@ class SyntheticMethods(thisTransformer: DenotTransformer) {
      *  ```
      */
     def valueHashCodeBody(implicit ctx: Context): Tree = {
-      assert(accessors.length == 1)
+      assert(accessors.nonEmpty)
+      assert(accessors.tail.forall(_.info.isPhantom))
       ref(accessors.head).select(nme.hashCode_).ensureApplied
     }
 

compiler/src/dotty/tools/dotc/typer/Checking.scala

@@ -490,13 +490,17 @@ object Checking {
           param.isTerm && !param.is(Flags.Accessor)
         }
         clParamAccessors match {
-          case List(param) =>
+          case param :: params =>
             if (param.is(Mutable))
               ctx.error(ValueClassParameterMayNotBeAVar(clazz, param), param.pos)
             if (param.info.isPhantom)
-              ctx.error("value class parameter must not be phantom", param.pos)
-          case _ =>
-            ctx.error(ValueClassNeedsExactlyOneValParam(clazz), clazz.pos)
+              ctx.error("value class first parameter must not be phantom", param.pos)
+            else {
+              for (p <- params if !p.info.isPhantom)
+                ctx.error("value class can only have one non phantom parameter", p.pos)
+            }
+          case Nil =>
+            ctx.error(ValueClassNeedsOneValParam(clazz), clazz.pos)
         }
       }
       stats.foreach(checkValueClassMember)

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -292,27 +292,6 @@ class CompilationTests extends ParallelTesting {
 
     tests.foreach(_.delete())
   }
-
-  private val (compilerSources, backendSources, backendJvmSources) = {
-    val compilerDir = Paths.get("../compiler/src")
-    val compilerSources0 = sources(Files.walk(compilerDir))
-
-    val backendDir = Paths.get("../scala-backend/src/compiler/scala/tools/nsc/backend")
-    val backendJvmDir = Paths.get("../scala-backend/src/compiler/scala/tools/nsc/backend/jvm")
-
-    // NOTE: Keep these exclusions synchronized with the ones in the sbt build (Build.scala)
-    val backendExcluded =
-      List("JavaPlatform.scala", "Platform.scala", "ScalaPrimitives.scala")
-    val backendJvmExcluded =
-      List("BCodeICodeCommon.scala", "GenASM.scala", "GenBCode.scala", "ScalacBackendInterface.scala", "BackendStats.scala")
-
-    val backendSources0 =
-      sources(Files.list(backendDir), excludedFiles = backendExcluded)
-    val backendJvmSources0 =
-      sources(Files.list(backendJvmDir), excludedFiles = backendJvmExcluded)
-
-    (compilerSources0, backendSources0, backendJvmSources0)
-  }
 }
 
 object CompilationTests {

compiler/test/dotty/tools/dotc/InterfaceEntryPointTest.scala

@@ -5,6 +5,7 @@ import org.junit.Test
 import org.junit.Assert._
 import interfaces._
 import scala.collection.mutable.ListBuffer
+import java.nio.file._
 
 /** Test that demonstrates how to use dotty-interfaces
  *
@@ -20,8 +21,12 @@ import scala.collection.mutable.ListBuffer
 class InterfaceEntryPointTest {
   @Test def runCompilerFromInterface = {
     val sources =
-      List("../tests/pos/HelloWorld.scala").map(p => new java.io.File(p).getPath())
-    val args = sources ++ List("-d", "../out/", "-usejavacp")
+      List("../tests/pos/HelloWorld.scala").map(p => Paths.get(p).toAbsolutePath().toString)
+    val out = Paths.get("../out/").toAbsolutePath()
+    if (Files.notExists(out))
+      Files.createDirectory(out)
+
+    val args = sources ++ List("-d", out.toString, "-usejavacp")
 
     val mainClass = Class.forName("dotty.tools.dotc.Main")
     val process = mainClass.getMethod("process",

compiler/test/dotty/tools/dotc/MissingCoreLibTests.scala

@@ -0,0 +1,34 @@
+package dotty
+package tools
+package dotc
+
+import org.junit.{ Test, AfterClass }
+
+import vulpix.{ ParallelTesting, SummaryReport, SummaryReporting, TestConfiguration }
+
+import scala.concurrent.duration._
+
+class MissingCoreLibTests extends ParallelTesting {
+  import MissingCoreLibTests._
+  import TestConfiguration._
+
+  // Test suite configuration --------------------------------------------------
+
+  def maxDuration = 30.seconds
+  def numberOfSlaves = 5
+  def safeMode = Properties.testsSafeMode
+  def isInteractive = SummaryReport.isInteractive
+  def testFilter = Properties.testsFilter
+
+  @Test def missingDottyLib: Unit = {
+    val classPath = mkClassPath(Jars.dottyCompiler :: Jars.dottyInterfaces :: Jars.dottyExtras) // missing Jars.dottyLib
+    val options = noCheckOptions ++ checkOptions ++ yCheckOptions ++ classPath
+    compileFile("../tests/neg/nolib/Foo.scala", options).checkExpectedErrors()
+  }
+
+}
+
+object MissingCoreLibTests {
+  implicit val summaryReport: SummaryReporting = new SummaryReport
+  @AfterClass def cleanup(): Unit = summaryReport.echoSummary()
+}

compiler/test/dotty/tools/dotc/reporting/ErrorMessagesTests.scala

@@ -787,14 +787,14 @@ class ErrorMessagesTests extends ErrorMessagesTest {
       assertEquals("variable i", param.show)
     }
 
-  @Test def valueClassNeedsExactlyOneVal =
+  @Test def valueClassNeedsOneVal =
     checkMessagesAfter("refchecks") {
-      """class MyValue(var i: Int, j: Int) extends AnyVal"""
+      """class MyValue() extends AnyVal"""
     }
     .expect { (ictx, messages) =>
       implicit val ctx: Context = ictx
       assertMessageCount(1, messages)
-      val ValueClassNeedsExactlyOneValParam(valueClass) :: Nil = messages
+      val ValueClassNeedsOneValParam(valueClass) :: Nil = messages
       assertEquals("class MyValue", valueClass.show)
     }