Merge remote-tracking branch 'upstream/master' into dotr-classpath

Author: rsoeldner

.drone.yml

@@ -1,3 +1,15 @@
+# We override the default clone step to workaround a bug with GitHub (see #3415)
+clone:
+  clone:
+    image: plugins/git
+    commands:
+      - sleep 5s
+      - git init
+      - git remote add origin $DRONE_REMOTE_URL
+      - git fetch --no-tags origin $DRONE_COMMIT_REF
+      - if [ $DRONE_BUILD_EVENT = "push" ]; then git reset --hard -q $DRONE_COMMIT_SHA; else git checkout -qf FETCH_HEAD; fi
+      - git submodule update --init --recursive
+
 pipeline:
   # TESTS:
   # We run tests in parallel. Tests run in a copy of the working directory to avoid conflict
@@ -13,16 +25,16 @@ pipeline:
     image: lampepfl/dotty:2017-10-20
     commands:
       - cp -R . /tmp/1/ && cd /tmp/1/
-      - ./project/scripts/sbt testAll
-      - ./project/scripts/sbt ";dotty-bench/jmh:run 1 1 tests/run/arrays.scala"
+      - ./project/scripts/sbt ";compile ;testAll"
+      - ./project/scripts/sbtTests
 
   test_bootstrapped:
     group: test
     image: lampepfl/dotty:2017-10-20
     commands:
       - cp -R . /tmp/2/ && cd /tmp/2/
-      - ./project/scripts/sbt dotty-bootstrapped/testAll
-      - ./project/scripts/sbt ";dotty-bench-bootstrapped/jmh:run 1 1 tests/run/arrays.scala"
+      - ./project/scripts/sbt ";dotty-bootstrapped/compile ;dotty-bootstrapped/testAll"
+      - ./project/scripts/sbtBootstrappedTests
 
   test_optimised:
     group: test

CONTRIBUTING renamed to CONTRIBUTING.md

@@ -9,7 +9,6 @@ This is the process for committing code to the Scala project. There are of cours
 1. Make sure you have signed the [Scala CLA](http://typesafe.com/contribute/cla/scala), if not, sign it.
 2. Before starting to work on a feature or a fix, it's good practice to ensure that:
     1. There is a ticket for your work in the project's [issue tracker](https://github.com/lampepfl/dotty/issues);
-    2. If not, create it first (perhaps given a thumbs up from the dotty-internals mailing list first);
     2. The ticket has been discussed and prioritized by the team.
 3. You should always perform your work in its own Git branch. The branch should be given a descriptive name that explains its intent. Some teams also like adding the ticket number and/or the [GitHub](http://github.com) user ID to the branch name, these details is up to each of the individual teams. (See below for more details on branch naming.)
 4. When the feature or fix is completed you should open a [Pull Request](https://help.github.com/articles/using-pull-requests) on GitHub.

README.md

@@ -7,8 +7,6 @@ Community build: [![Community Build Status](https://travis-ci.org/lampepfl/dotty
 
 * [Homepage](http://dotty.epfl.ch)
 * [Documentation](http://dotty.epfl.ch/docs)
-* [FAQ](http://dotty.epfl.ch/#why-dotty)
-* [Mailing list](https://groups.google.com/forum/#!forum/dotty-internals)
 
 Try it out
 ==========

bench/scripts/collection-strawman-cold.sh

@@ -1,2 +1,2 @@
 #!/usr/bin/env bash
-find collection-strawman/src/main/ -type f \( -name "*.scala" -or -name "*.java" \) -exec echo "dotty-bench-bootstrapped/jmh:run 0 1 10" {} + | sbt
+find collection-strawman/collections/src/main/ -type f \( -name "*.scala" -or -name "*.java" \) -exec echo "dotty-bench-bootstrapped/jmh:run 0 1 10" {} + | sbt

bench/scripts/collection-strawman.sh

@@ -1,2 +1,2 @@
 #!/usr/bin/env bash
-find collection-strawman/src/main/ -type f \( -name "*.scala" -or -name "*.java" \) -exec echo "dotty-bench-bootstrapped/jmh:run" {} + | sbt
+find collection-strawman/collections/src/main/ -type f \( -name "*.scala" -or -name "*.java" \) -exec echo "dotty-bench-bootstrapped/jmh:run" {} + | sbt

bot/src/dotty/tools/bot/PullRequestService.scala

@@ -267,7 +267,7 @@ trait PullRequestService {
          |> 1. Limit the subject line to 72 characters
          |> 1. Capitalize the subject line
          |> 1. Do not end the subject line with a period
-         |> 1. Use the imperative mood in the subject line ("Added" instead of "Add")
+         |> 1. Use the imperative mood in the subject line ("Add" instead of "Added")
          |> 1. Wrap the body at 80 characters
          |> 1. Use the body to explain what and why vs. how
          |>

collection-strawman

@@ -5,7 +5,7 @@ import dotty.tools.dotc.ast.Trees
 import dotty.tools.dotc
 import dotty.tools.dotc.backend.jvm.DottyPrimitives
 import dotty.tools.dotc.core.Flags.FlagSet
-import dotty.tools.dotc.transform.Erasure
+import dotty.tools.dotc.transform.{Erasure, GenericSignatures}
 import dotty.tools.dotc.transform.SymUtils._
 import java.io.{File => JFile}
 
@@ -489,10 +489,97 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
 
   def getSingleOutput: Option[AbstractFile] = None // todo: implement
 
+  // @M don't generate java generics sigs for (members of) implementation
+  // classes, as they are monomorphic (TODO: ok?)
+  private final def needsGenericSignature(sym: Symbol): Boolean = !(
+    // pp: this condition used to include sym.hasexpandedname, but this leads
+    // to the total loss of generic information if a private member is
+    // accessed from a closure: both the field and the accessor were generated
+    // without it.  This is particularly bad because the availability of
+    // generic information could disappear as a consequence of a seemingly
+    // unrelated change.
+       ctx.base.settings.YnoGenericSig.value
+    || sym.is(Flags.Artifact)
+    || sym.is(Flags.allOf(Flags.Method, Flags.Lifted))
+    || sym.is(Flags.Bridge)
+  )
+
+  private def verifySignature(sym: Symbol, sig: String)(implicit ctx: Context): Unit = {
+    import scala.tools.asm.util.CheckClassAdapter
+    def wrap(body: => Unit): Boolean =
+      try { body; true }
+      catch { case ex: Throwable => println(ex.getMessage); false }
+
+    val valid = wrap {
+      if (sym.is(Flags.Method)) {
+        CheckClassAdapter.checkMethodSignature(sig)
+      }
+      else if (sym.isTerm) {
+        CheckClassAdapter.checkFieldSignature(sig)
+      }
+      else {
+        CheckClassAdapter.checkClassSignature(sig)
+      }
+    }
+
+    if(!valid) {
+      ctx.warning(
+        i"""|compiler bug: created invalid generic signature for $sym in ${sym.denot.owner.showFullName}
+            |signature: $sig
+            |if this is reproducible, please report bug at https://github.com/lampepfl/dotty/issues
+        """.trim, sym.pos)
+    }
+  }
+
+  /**
+   * Generates the generic signature for `sym` before erasure.
+   *
+   * @param sym   The symbol for which to generate a signature.
+   * @param owner The owner of `sym`.
+   * @return The generic signature of `sym` before erasure, as specified in the Java Virtual
+   *         Machine Specification, §4.3.4, or `null` if `sym` doesn't need a generic signature.
+   * @see https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.3.4
+   */
+  def getGenericSignature(sym: Symbol, owner: Symbol): String = {
+    ctx.atPhase(ctx.erasurePhase) { implicit ctx =>
+      val memberTpe =
+        if (sym.is(Flags.Method)) sym.denot.info
+        else owner.denot.thisType.memberInfo(sym)
+      getGenericSignature(sym, owner, memberTpe).orNull
+    }
+  }
 
-  def getGenericSignature(sym: Symbol, owner: Symbol): String = null // todo: implement
+  def getStaticForwarderGenericSignature(sym: Symbol, moduleClass: Symbol): String = {
+    // scala/bug#3452 Static forwarder generation uses the same erased signature as the method if forwards to.
+    // By rights, it should use the signature as-seen-from the module class, and add suitable
+    // primitive and value-class boxing/unboxing.
+    // But for now, just like we did in mixin, we just avoid writing a wrong generic signature
+    // (one that doesn't erase to the actual signature). See run/t3452b for a test case.
+
+    val memberTpe = ctx.atPhase(ctx.erasurePhase) { implicit ctx => moduleClass.denot.thisType.memberInfo(sym) }
+    val erasedMemberType = TypeErasure.erasure(memberTpe)
+    if (erasedMemberType =:= sym.denot.info)
+      getGenericSignature(sym, moduleClass, memberTpe).orNull
+    else null
+  }
+
+  private def getGenericSignature(sym: Symbol, owner: Symbol, memberTpe: Type)(implicit ctx: Context): Option[String] =
+    if (needsGenericSignature(sym)) {
+      val erasedTypeSym = sym.denot.info.typeSymbol
+      if (erasedTypeSym.isPrimitiveValueClass) {
+        None
+      } else {
+        val jsOpt = GenericSignatures.javaSig(sym, memberTpe)
+        if (ctx.settings.XverifySignatures.value) {
+          jsOpt.foreach(verifySignature(sym, _))
+        }
+
+        jsOpt
+      }
+    } else {
+      None
+    }
 
-  def getStaticForwarderGenericSignature(sym: Symbol, moduleClass: Symbol): String = null // todo: implement
 
 
   def sourceFileFor(cu: CompilationUnit): String = cu.source.file.name

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

@@ -7,6 +7,7 @@ import dotty.tools.dotc.core.Phases.Phase
 import dotty.tools.dotc.core.Names.TypeName
 
 import scala.collection.mutable
+import scala.collection.JavaConverters._
 import scala.tools.asm.{ClassVisitor, CustomAttr, FieldVisitor, MethodVisitor}
 import scala.tools.nsc.backend.jvm._
 import dotty.tools.dotc
@@ -26,14 +27,16 @@ import Denotations._
 import Phases._
 import java.lang.AssertionError
 import java.io.{DataOutputStream, File => JFile}
+import java.nio.file.{Files, FileSystem, FileSystems, Path => JPath}
+
+import dotty.tools.io.{Directory, File, Jar}
 
 import scala.tools.asm
 import scala.tools.asm.tree._
 import dotty.tools.dotc.util.{DotClass, Positions}
 import tpd._
 import StdNames._
-
-import dotty.tools.io.{AbstractFile, Directory, PlainDirectory}
+import dotty.tools.io._
 
 class GenBCode extends Phase {
   def phaseName: String = "genBCode"
@@ -46,17 +49,35 @@ class GenBCode extends Phase {
     superCallsMap.put(sym, old + calls)
   }
 
-  def outputDir(implicit ctx: Context): AbstractFile =
-    new PlainDirectory(ctx.settings.outputDir.value)
+  private[this] var myOutput: AbstractFile = _
+
+  protected def outputDir(implicit ctx: Context): AbstractFile = {
+    if (myOutput eq null) {
+      val path = Directory(ctx.settings.outputDir.value)
+      myOutput =
+        if (path.extension == "jar") JarArchive.create(path)
+        else new PlainDirectory(path)
+    }
+    myOutput
+  }
 
   def run(implicit ctx: Context): Unit = {
     new GenBCodePipeline(entryPoints.toList,
         new DottyBackendInterface(outputDir, superCallsMap.toMap)(ctx))(ctx).run(ctx.compilationUnit.tpdTree)
     entryPoints.clear()
   }
+
+  override def runOn(units: List[CompilationUnit])(implicit ctx: Context) = {
+    try super.runOn(units)
+    finally myOutput match {
+      case jar: JarArchive =>
+        jar.close()
+      case _ =>
+    }
+  }
 }
 
-class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInterface)(implicit val ctx: Context) extends BCodeSyncAndTry{
+class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInterface)(implicit val ctx: Context) extends BCodeSyncAndTry {
 
   var tree: Tree = _
 

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

@@ -1,38 +1,12 @@
 package dotty.tools.backend.jvm
 
-import dotty.tools.dotc.ast.Trees.Thicket
-import dotty.tools.dotc.ast.{Trees, tpd}
+import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.core.Contexts.Context
-import dotty.tools.dotc.core.Types
+import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.transform.MegaPhase._
-import dotty.tools.dotc
-import dotty.tools.dotc.backend.jvm.DottyPrimitives
-import dotty.tools.dotc.core.Flags.FlagSet
-import dotty.tools.dotc.transform.Erasure
-import dotty.tools.dotc.transform.SymUtils._
-import java.io.{File => JFile}
 
-import scala.collection.generic.Clearable
 import scala.collection.mutable
-import scala.collection.mutable.{ListBuffer, ArrayBuffer}
-import scala.reflect.ClassTag
-import dotty.tools.io.{Directory, PlainDirectory, AbstractFile}
-import scala.tools.asm.{ClassVisitor, FieldVisitor, MethodVisitor}
-import scala.tools.nsc.backend.jvm.{BCodeHelpers, BackendInterface}
-import dotty.tools.dotc.core._
-import Periods._
-import SymDenotations._
-import Contexts._
-import Types._
-import Symbols._
-import Denotations._
-import Phases._
-import java.lang.AssertionError
-import dotty.tools.dotc.util.Positions.Position
-import Decorators._
-import tpd._
-import Flags._
-import StdNames.nme
 
 /**
  * Verifies that each Label DefDef has only a single address to jump back and
@@ -82,68 +56,48 @@ import StdNames.nme
  * @author Dmitry Petrashko
  */
 class LabelDefs extends MiniPhase {
-  def phaseName: String = "labelDef"
+  import tpd._
 
-  val queue = new ArrayBuffer[Tree]()
-  val beingAppended = new mutable.HashSet[Symbol]()
-  var labelLevel = 0
+  def phaseName: String = "labelDef"
 
-  override def transformDefDef(tree: tpd.DefDef)(implicit ctx: Context): tpd.Tree = {
-    if (tree.symbol is Flags.Label) tree
+  override def transformDefDef(tree: DefDef)(implicit ctx: Context): Tree = {
+    if (tree.symbol is Label) tree
     else {
-      collectLabelDefs.clear
-      val newRhs = collectLabelDefs.transform(tree.rhs)
-      var labelDefs = collectLabelDefs.labelDefs
+      val labelDefs = collectLabelDefs(tree.rhs)
 
       def putLabelDefsNearCallees = new TreeMap() {
-
-        override def transform(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = {
+        override def transform(tree: Tree)(implicit ctx: Context): Tree = {
           tree match {
             case t: Apply if labelDefs.contains(t.symbol) =>
               val labelDef = labelDefs(t.symbol)
               labelDefs -= t.symbol
-
-              val labelDef2 = transform(labelDef)
+              val labelDef2 = cpy.DefDef(labelDef)(rhs = transform(labelDef.rhs))
               Block(labelDef2:: Nil, t)
-
+            case t: DefDef =>
+              assert(t.symbol is Label)
+              EmptyTree
             case _ => if (labelDefs.nonEmpty) super.transform(tree) else tree
           }
         }
       }
 
-      val res = cpy.DefDef(tree)(rhs = putLabelDefsNearCallees.transform(newRhs))
-
-      res
+      if (labelDefs.isEmpty) tree
+      else cpy.DefDef(tree)(rhs = putLabelDefsNearCallees.transform(tree.rhs))
     }
   }
 
-  object collectLabelDefs extends TreeMap() {
-
+  private def collectLabelDefs(tree: Tree)(implicit ctx: Context): mutable.HashMap[Symbol, DefDef] = {
     // labelSymbol -> Defining tree
-    val labelDefs = new mutable.HashMap[Symbol, Tree]()
-
-    def clear = {
-      labelDefs.clear()
-    }
-
-    override def transform(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = tree match {
-      case t: Template => t
-      case t: Block =>
-        val r = super.transform(t)
-        r match {
-          case t: Block if t.stats.isEmpty => t.expr
-          case _ => r
-        }
-      case t: DefDef =>
-        assert(t.symbol is Flags.Label)
-        val r = super.transform(tree)
-        labelDefs(r.symbol) = r
-        EmptyTree
-      case t: Apply if t.symbol is Flags.Label =>
-        val sym = t.symbol
-        super.transform(tree)
-      case _ =>
-        super.transform(tree)
-    }
+    val labelDefs = new mutable.HashMap[Symbol, DefDef]()
+    new TreeTraverser {
+      override def traverse(tree: Tree)(implicit ctx: Context): Unit = tree match {
+        case t: DefDef =>
+          assert(t.symbol is Label)
+          labelDefs(t.symbol) = t
+          traverseChildren(t)
+        case _ => traverseChildren(tree)
+      }
+    }.traverse(tree)
+    labelDefs
   }
 }