Merge branch 'master' into add-transparent-7

Author: OlivierBlanvillain

.drone.yml

@@ -23,23 +23,23 @@ 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-08-31
+    image: lampepfl/dotty:2018-09-14-2
     commands:
       - cp -R . /tmp/1/ && cd /tmp/1/
       - ./project/scripts/sbt ";compile ;test"
       - ./project/scripts/cmdTests
 
   test_bootstrapped:
     group: test
-    image: lampepfl/dotty:2018-08-31
+    image: lampepfl/dotty:2018-09-14-2
     commands:
       - cp -R . /tmp/2/ && cd /tmp/2/
       - ./project/scripts/sbt ";dotty-bootstrapped/compile ;dotty-bootstrapped/test"
       - ./project/scripts/bootstrapCmdTests
 
   test_sbt:
     group: test
-    image: lampepfl/dotty:2018-08-31
+    image: lampepfl/dotty:2018-09-14-2
     commands:
       - cp -R . /tmp/4/ && cd /tmp/4/
       - ./project/scripts/sbt sbt-dotty/scripted
@@ -49,7 +49,7 @@ pipeline:
 
   # DOCUMENTATION:
   documentation:
-    image: lampepfl/dotty:2018-08-31
+    image: lampepfl/dotty:2018-09-14-2
     commands:
       - ./project/scripts/genDocs
     secrets: [ bot_pass ]
@@ -61,7 +61,7 @@ pipeline:
   # PUBLISHING:
   # Publishing expect NIGHTLYBUILD or RELEASEBUILD to be set. See dottyVersion in Build.scala
   publish_nightly:
-    image: lampepfl/dotty:2018-08-31
+    image: lampepfl/dotty:2018-09-14-2
     environment:
       - NIGHTLYBUILD=yes
     commands:
@@ -72,7 +72,7 @@ pipeline:
       environment: nightly
 
   publish_release:
-    image: lampepfl/dotty:2018-08-31
+    image: lampepfl/dotty:2018-09-14-2
     environment:
       - RELEASEBUILD=yes
     commands:
@@ -96,7 +96,7 @@ pipeline:
       event: tag
 
   publish_sbt_release:
-    image: lampepfl/dotty:2018-08-31
+    image: lampepfl/dotty:2018-09-14-2
     environment:
       - RELEASEBUILD=yes
     commands:

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

@@ -422,6 +422,10 @@ class Definitions {
     def Seq_drop(implicit ctx: Context) = Seq_dropR.symbol
     lazy val Seq_lengthCompareR = SeqClass.requiredMethodRef(nme.lengthCompare)
     def Seq_lengthCompare(implicit ctx: Context) = Seq_lengthCompareR.symbol
+    lazy val Seq_lengthR = SeqClass.requiredMethodRef(nme.length)
+    def Seq_length(implicit ctx: Context) = Seq_lengthR.symbol
+    lazy val Seq_toSeqR = SeqClass.requiredMethodRef(nme.toSeq)
+    def Seq_toSeq(implicit ctx: Context) = Seq_toSeqR.symbol
 
   lazy val ArrayType: TypeRef = ctx.requiredClassRef("scala.Array")
   def ArrayClass(implicit ctx: Context) = ArrayType.symbol.asClass

compiler/src/dotty/tools/dotc/tastyreflect/StandardDefinitions.scala

@@ -80,5 +80,6 @@ trait StandardDefinitions extends scala.tasty.reflect.StandardDefinitions {
     def ObjectType: Type = defn.ObjectType
     def NothingType: Type = defn.NothingType
     def NullType: Type = defn.NullType
+    def StringType: Type = defn.StringType
   }
 }

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

@@ -254,7 +254,7 @@ object PatternMatcher {
        */
       def matchElemsPlan(seqSym: Symbol, args: List[Tree], exact: Boolean, onSuccess: Plan) = {
         val selectors = args.indices.toList.map(idx =>
-          ref(seqSym).select(nme.apply).appliedTo(Literal(Constant(idx))))
+          ref(seqSym).select(defn.Seq_apply.matchingMember(seqSym.info)).appliedTo(Literal(Constant(idx))))
         TestPlan(LengthTest(args.length, exact), seqSym, seqSym.pos,
           matchArgsPlan(selectors, args, onSuccess))
       }
@@ -265,8 +265,13 @@ object PatternMatcher {
       def unapplySeqPlan(getResult: Symbol, args: List[Tree]): Plan = args.lastOption match {
         case Some(VarArgPattern(arg)) =>
           val matchRemaining =
-            if (args.length == 1)
-              patternPlan(getResult, arg, onSuccess)
+            if (args.length == 1) {
+              val toSeq = ref(getResult)
+                .select(defn.Seq_toSeq.matchingMember(getResult.info))
+              letAbstract(toSeq) { toSeqResult =>
+                patternPlan(toSeqResult, arg, onSuccess)
+              }
+            }
             else {
               val dropped = ref(getResult)
                 .select(defn.Seq_drop.matchingMember(getResult.info))
@@ -638,11 +643,18 @@ object PatternMatcher {
         case EqualTest(tree) =>
           tree.equal(scrutinee)
         case LengthTest(len, exact) =>
-          scrutinee
-            .select(defn.Seq_lengthCompare.matchingMember(scrutinee.tpe))
-            .appliedTo(Literal(Constant(len)))
-            .select(if (exact) defn.Int_== else defn.Int_>=)
-            .appliedTo(Literal(Constant(0)))
+          val lengthCompareSym = defn.Seq_lengthCompare.matchingMember(scrutinee.tpe)
+          if (lengthCompareSym.exists)
+            scrutinee
+              .select(defn.Seq_lengthCompare.matchingMember(scrutinee.tpe))
+              .appliedTo(Literal(Constant(len)))
+              .select(if (exact) defn.Int_== else defn.Int_>=)
+              .appliedTo(Literal(Constant(0)))
+          else // try length
+            scrutinee
+              .select(defn.Seq_length.matchingMember(scrutinee.tpe))
+              .select(if (exact) defn.Int_== else defn.Int_>=)
+              .appliedTo(Literal(Constant(len)))
         case TypeTest(tpt) =>
           val expectedTp = tpt.tpe
 

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

@@ -101,13 +101,44 @@ object Applications {
       Nil
     }
 
+    /** If `getType` is of the form:
+     *  ```
+     *  {
+     *    def lengthCompare(len: Int): Int // or, def length: Int
+     *    def apply(i: Int): T = a(i)
+     *    def drop(n: Int): scala.Seq[T]
+     *    def toSeq: scala.Seq[T]
+     *  }
+     *  ```
+     *  returns `T`, otherwise NoType.
+     */
+    def unapplySeqTypeElemTp(getTp: Type): Type = {
+      def lengthTp = ExprType(defn.IntType)
+      def lengthCompareTp = MethodType(List(defn.IntType), defn.IntType)
+      def applyTp(elemTp: Type) = MethodType(List(defn.IntType), elemTp)
+      def dropTp(elemTp: Type) = MethodType(List(defn.IntType), defn.SeqType.appliedTo(elemTp))
+      def toSeqTp(elemTp: Type) = ExprType(defn.SeqType.appliedTo(elemTp))
+
+      // the result type of `def apply(i: Int): T`
+      val elemTp = getTp.member(nme.apply).suchThat(_.info <:< applyTp(WildcardType)).info.resultType
+
+      def hasMethod(name: Name, tp: Type) =
+        getTp.member(name).suchThat(getTp.memberInfo(_) <:< tp).exists
+
+      val isValid =
+        elemTp.exists &&
+        (hasMethod(nme.lengthCompare, lengthCompareTp) || hasMethod(nme.length, lengthTp)) &&
+        hasMethod(nme.drop, dropTp(elemTp)) &&
+        hasMethod(nme.toSeq, toSeqTp(elemTp))
+
+      if (isValid) elemTp else NoType
+    }
+
     if (unapplyName == nme.unapplySeq) {
-      if (unapplyResult derivesFrom defn.SeqClass)
-        seqSelector :: Nil
-      else if (isGetMatch(unapplyResult, pos) && getTp.derivesFrom(defn.SeqClass)) {
-        val seqArg = (if (ctx.isDependent) getTp.widenTermRefExpr.annotatedToRepeated.dealiasKeepAnnots else getTp)
-          .elemType.hiBound
-        if (seqArg.exists) args.map(Function.const(seqArg))
+      if (isGetMatch(unapplyResult, pos)) {
+        val depGetTp = if (ctx.isDependent) getTp.widenTermRefExpr.annotatedToRepeated.dealiasKeepAnnots else getTp
+        val elemTp = unapplySeqTypeElemTp(depGetTp)
+        if (elemTp.exists) args.map(Function.const(elemTp))
         else fail
       }
       else fail

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

@@ -108,6 +108,20 @@ object RefChecks {
     case _ =>
   }
 
+  /** Disallow using trait parameters as prefix for its parents.
+   *
+   *  The rationale is to ensure outer-related NPE never happen in Scala.
+   *  Otherwise, outer NPE may happen, see tests/neg/i5083.scala
+   */
+  private def checkParentPrefix(cls: Symbol, parent: Tree)(implicit ctx: Context): Unit =
+    parent.tpe.typeConstructor match {
+      case TypeRef(ref: TermRef, _) =>
+        val paramRefs = ref.namedPartsWith(ntp => ntp.symbol.enclosingClass == cls)
+        if (paramRefs.nonEmpty)
+          ctx.error("trait parameters cannot be used as parent prefixes", parent.pos)
+      case _ =>
+    }
+
   /** Check that a class and its companion object to not both define
    *  a class or module with same name
    */
@@ -961,6 +975,7 @@ class RefChecks extends MiniPhase { thisPhase =>
     val cls = ctx.owner
     checkOverloadedRestrictions(cls)
     checkParents(cls)
+    if (cls.is(Trait)) tree.parents.foreach(checkParentPrefix(cls, _))
     checkCompanionNameClashes(cls)
     checkAllOverrides(cls)
     tree

compiler/test/dotc/run-test-pickling.blacklist

@@ -83,3 +83,4 @@ typelevel-patmat.scala
 typelevel.scala
 typelevel1.scala
 typelevel3.scala
+xml-interpolation

compiler/test/dotty/tools/vulpix/ParallelTesting.scala

@@ -8,6 +8,7 @@ import java.util.HashMap
 import java.nio.file.StandardCopyOption.REPLACE_EXISTING
 import java.nio.file.{Files, NoSuchFileException, Path, Paths}
 import java.util.concurrent.{TimeUnit, TimeoutException, Executors => JExecutors}
+import java.util.{Timer, TimerTask}
 
 import scala.io.Source
 import scala.util.control.NonFatal
@@ -285,11 +286,11 @@ trait ParallelTesting extends RunnerOrchestration { self =>
       realStderr.println(msg + paddingRight)
     }
 
-    /** A single `Runnable` that prints a progress bar for the curent `Test` */
-    private def createProgressMonitor: Runnable = () => {
+    /** Print a progress bar for the curent `Test` */
+    private def updateProgressMonitor(): Unit = {
       val start = System.currentTimeMillis
       var tCompiled = testSourcesCompleted
-      while (tCompiled < sourceCount) {
+      if (tCompiled < sourceCount) {
         val timestamp = (System.currentTimeMillis - start) / 1000
         val progress = (tCompiled.toDouble / sourceCount * 40).toInt
 
@@ -299,16 +300,14 @@ trait ParallelTesting extends RunnerOrchestration { self =>
             (" " * (39 - progress)) +
             s"] completed ($tCompiled/$sourceCount, $failureCount failed, ${timestamp}s)\r"
         )
-
-        Thread.sleep(100)
-        tCompiled = testSourcesCompleted
       }
-
-      val timestamp = (System.currentTimeMillis - start) / 1000
-      // println, otherwise no newline and cursor at start of line
-      realStdout.println(
-        s"[=======================================] completed ($sourceCount/$sourceCount, $failureCount failed, ${timestamp}s)"
-      )
+      else {
+        val timestamp = (System.currentTimeMillis - start) / 1000
+        // println, otherwise no newline and cursor at start of line
+        realStdout.print(
+          s"[=======================================] completed ($sourceCount/$sourceCount, $failureCount failed, ${timestamp}s)\r"
+        )
+      }
     }
 
     /** Wrapper function to make sure that the compiler itself did not crash -
@@ -465,7 +464,14 @@ trait ParallelTesting extends RunnerOrchestration { self =>
           case None => JExecutors.newWorkStealingPool()
         }
 
-        if (isInteractive && !suppressAllOutput) pool.submit(createProgressMonitor)
+        val timer = new Timer()
+        val logProgress = isInteractive && !suppressAllOutput
+        if (logProgress) {
+          val task = new TimerTask {
+            def run() = updateProgressMonitor()
+          }
+          timer.schedule(task, 100, 200)
+        }
 
         val eventualResults = filteredSources.map { target =>
           pool.submit(encapsulatedCompilation(target))
@@ -481,6 +487,12 @@ trait ParallelTesting extends RunnerOrchestration { self =>
 
         eventualResults.foreach(_.get)
 
+        if (logProgress) {
+          timer.cancel()
+          // update progress one last time
+          updateProgressMonitor()
+        }
+
         if (didFail) {
           reportFailed()
           failedTestSources.toSet.foreach(addFailedTest)

docs/docs/reference/changed/pattern-matching.md

@@ -63,12 +63,23 @@ object FirstChars {
 ```
 
 
-## Seq Pattern
+## Name-based Seq Pattern
 
 - Extractor defines `def unapplySeq(x: T): U`
 - `U` has (parameterless `def` or `val`) members `isEmpty: Boolean` and `get: S`
-- `S <: Seq[V]`
-- Pattern-matching on `N` pattern with types `V, V, ..., V`, where `N` is the runtime size of the `Seq`.
+- `S` conforms to `X`, `T2` and `T3` conform to `T1`
+
+```Scala
+type X = {
+  def lengthCompare(len: Int): Int // or, `def length: Int`
+  def apply(i: Int): T1
+  def drop(n: Int): scala.Seq[T2]
+  def toSeq: scala.Seq[T3]
+}
+```
+
+- Pattern-matching on _exactly_ `N` simple patterns with types `T1, T1, ..., T1`, where `N` is the runtime size of the sequence, or
+- Pattern-matching on `>= N` simple patterns and _a vararg pattern_ (e.g., `xs: _*`) with types `T1, T1, ..., T1, Seq[T1]`, where `N` is the minimum size of the sequence.
 
 <!-- To be kept in sync with tests/new/patmat-spec.scala -->
 
@@ -87,7 +98,7 @@ object CharList {
 ```
 
 
-## Name Based Pattern
+## Name-based Pattern
 
 - Extractor defines `def unapply(x: T): U`
 - `U` has (parameterless `def` or `val`) members `isEmpty: Boolean` and `get: S`

language-server/test/dotty/tools/languageserver/util/server/TestFile.scala

@@ -5,7 +5,7 @@ import java.nio.file.{Path, Paths}
 import org.eclipse.lsp4j.TextDocumentIdentifier
 
 class TestFile(val file: String) extends AnyVal {
-  def uri: String = s"file://${TestFile.sourceDir}/$file"
+  def uri: String = TestFile.sourceDir.resolve(file).toUri.toString
 }
 
 object TestFile {

language-server/test/dotty/tools/languageserver/util/server/TestServer.scala

@@ -15,15 +15,18 @@ class TestServer(testFolder: Path) {
 
   private[this] def init(): InitializeResult = {
     // Fill the configuration with values populated by sbt
-    def showSeq[T](lst: Seq[T]): String = lst.map(elem => '"' + elem.toString + '"').mkString("[ ", ", ", " ]")
+    def showSeq[T](lst: Seq[T]): String =
+      lst
+        .map(elem => '"' + elem.toString.replace('\\', '/') + '"')
+        .mkString("[ ", ", ", " ]")
     val dottyIdeJson: String =
       s"""[ {
          |  "id" : "dotty-ide-test",
          |  "compilerVersion" : "${BuildInfo.ideTestsCompilerVersion}",
          |  "compilerArguments" : ${showSeq(BuildInfo.ideTestsCompilerArguments)},
          |  "sourceDirectories" : ${showSeq(BuildInfo.ideTestsSourceDirectories)},
          |  "dependencyClasspath" : ${showSeq(BuildInfo.ideTestsDependencyClasspath)},
-         |  "classDirectory" : "${BuildInfo.ideTestsClassDirectory}"
+         |  "classDirectory" : "${BuildInfo.ideTestsClassDirectory.toString.replace('\\','/')}"
          |}
          |]""".stripMargin
     val configFile = testFolder.resolve(DottyLanguageServer.IDE_CONFIG_FILE)

library/src/scala/tasty/reflect/StandardDefinitions.scala

@@ -212,5 +212,8 @@ trait StandardDefinitions extends TastyCore {
 
     /** The type of core type `Null`. */
     def NullType: Type
+
+    /** The type for `scala.String`. */
+    def StringType: Type
   }
 }