update to Dotty 0.18.1 Nightly

Author: bishabosha

.circleci/config.yml

@@ -84,7 +84,7 @@ workflows:
       - scala_job:
           name: dotty
           java_version: jdk8
-          scala_version: 0.17.0-RC1
+          scala_version: 0.18.1-bin-20190826-26217ce-NIGHTLY
       - scala_job:
           name: jdk11_2.12.8
           java_version: jdk11
@@ -96,7 +96,7 @@ workflows:
       - scala_job:
           name: jdk11_dotty
           java_version: jdk11
-          scala_version: 0.17.0-RC1
+          scala_version: 0.18.1-bin-20190826-26217ce-NIGHTLY
       - scalajs_job:
           name: sjs0.6_2.12
           scala_version: 2.12.8

.travis.yml

@@ -3,7 +3,7 @@ language: scala
 scala:
   - 2.12.8
   - 2.13.0
-  - 0.17.0-RC1
+  - 0.18.1-bin-20190826-26217ce-NIGHTLY
 
 env:
   global:
@@ -22,9 +22,9 @@ env:
 
 matrix:
   exclude:
-    - scala: 0.17.0-RC1
+    - scala: 0.18.1-bin-20190826-26217ce-NIGHTLY
       env: SCALAJS_VERSION=0.6.28   ADOPTOPENJDK=8
-    - scala: 0.17.0-RC1
+    - scala: 0.18.1-bin-20190826-26217ce-NIGHTLY
       env: SCALAJS_VERSION=1.0.0-M8 ADOPTOPENJDK=8
 
 before_install:

build.sbt

@@ -10,8 +10,9 @@ lazy val configSettings: Seq[Setting[_]] = Seq(
       val sv = scalaVersion.value
       Seq(
         CrossVersion.partialVersion(sv) match {
-          case Some((2, 13)) => file(dir.getPath ++ "-2.13+")
-          case _             => file(dir.getPath ++ "-2.13-")
+          case Some((2, 13))           => file(dir.getPath ++ "-2.13+")
+          case Some((0, v)) if v >= 18 => file(dir.getPath ++ "-2.13+")
+          case _                       => file(dir.getPath ++ "-2.13-")
         },
         CrossVersion.partialVersion(sv) match {
           case Some((2, _))  => file(dir.getPath ++ "-2.x")
@@ -30,7 +31,7 @@ lazy val xml = crossProject(JSPlatform, JVMPlatform)
   .settings(scalaModuleSettings)
   .jvmSettings(scalaModuleSettingsJVM)
   .jvmSettings(
-    crossScalaVersions += "0.17.0-RC1"
+    crossScalaVersions += "0.18.1-bin-20190826-26217ce-NIGHTLY"
   )
   .settings(
     name    := "scala-xml",

jvm/src/test/scala/scala/xml/ReuseNodesTest.scala

@@ -1,5 +1,7 @@
 package scala.xml
 
+import language.implicitConversions
+
 import scala.xml.transform._
 import scala.collection.Seq
 import org.junit.Assert.assertSame
@@ -9,19 +11,19 @@ import org.junit.experimental.theories.DataPoints
 import org.junit.runner.RunWith
 /**
  * This test verifies that after the transform, the resultant xml node
- * uses as many old nodes as possible. 
- * 
- * Three transformers class for case - 
- * One for original, one for modified, and one proposed which shows 
+ * uses as many old nodes as possible.
+ *
+ * Three transformers class for case -
+ * One for original, one for modified, and one proposed which shows
  * all are equivalent when it comes to reusing as many nodes as possible
  */
 object ReuseNodesTest {
- 
+
   class OriginalTranformr(rules: RewriteRule*) extends RuleTransformer(rules:_*) {
     override def transform(ns: Seq[Node]): Seq[Node] = {
       val xs = ns.toStream map transform
       val (xs1, xs2) = xs zip ns span { case (x, n) => unchanged(n, x) }
-       
+
       if (xs2.isEmpty) ns
       else (xs1 map (_._2)) ++ xs2.head._1 ++ transform(ns drop (xs1.length + 1))
     }
@@ -31,7 +33,7 @@ object ReuseNodesTest {
   class ModifiedTranformr(rules: RewriteRule*) extends RuleTransformer(rules:_*) {
     override def transform(ns: Seq[Node]): Seq[Node] = {
       val changed = ns flatMap transform
-      
+
       if (changed.length != ns.length || changed.zip(ns).exists(p => p._1 != p._2)) changed
       else ns
     }
@@ -42,13 +44,13 @@ object ReuseNodesTest {
     override def transform(ns: Seq[Node]): Seq[Node] = {
       val xs = ns.toStream map transform
       val (xs1, xs2) = xs zip ns span { case (x, n) => unchanged(n, x) }
-       
+
       if (xs2.isEmpty) ns
       else (xs1 map (_._2)) ++ xs2.head._1 ++ transform(ns drop (xs1.length + 1))
     }
     override def transform(n:Node): Seq[Node] = super.transform(n)
   }
-   
+
   def rewriteRule = new RewriteRule {
     override def transform(n: Node): NodeSeq = n match {
       case n if n.label == "change" => Elem(
@@ -57,7 +59,7 @@ object ReuseNodesTest {
     }
   }
 
-  @DataPoints 
+  @DataPoints
   def tranformers() = Array(
       new OriginalTranformr(rewriteRule),
       new ModifiedTranformr(rewriteRule),
@@ -66,34 +68,34 @@ object ReuseNodesTest {
 
 @RunWith(classOf[Theories])
 class ReuseNodesTest {
-   
+
   @Theory
-  def transformReferentialEquality(rt:RuleTransformer) = { 
+  def transformReferentialEquality(rt:RuleTransformer) = {
     val original = <p><lost/></p>
     val tranformed = rt.transform(original)
     assertSame(original, tranformed)
   }
-      
+
   @Theory
-  def transformReferentialEqualityOnly(rt:RuleTransformer) = { 
+  def transformReferentialEqualityOnly(rt:RuleTransformer) = {
     val original = <changed><change><lost/><a><b><c/></b></a></change><a><b><c/></b></a></changed>
     val transformed = rt.transform(original)
     recursiveAssert(original,transformed)
   }
-  
+
   def recursiveAssert(original:Seq[Node], transformed:Seq[Node]):Unit = {
-    original zip transformed foreach { 
-      case (x, y) => recursiveAssert(x, y) 
+    original zip transformed foreach {
+      case (x, y) => recursiveAssert(x, y)
     }
   }
-  
+
   def recursiveAssert(original:Node, transformed:Node):Unit = {
-    transformed.label match { 
+    transformed.label match {
       case "changed" => // do nothing expect this node to be changed
         recursiveAssert(original.child,transformed.child)
       case _ => {
         assertSame(original, transformed)
-        // No need to check for children, node being immuatable 
+        // No need to check for children, node being immuatable
         // children can't be different if parents are referentially equal
       }
     }

shared/src/main/scala/scala/xml/dtd/impl/Base.scala renamed to shared/src/main/scala-2.x/scala/xml/dtd/impl/Base.scala

@@ -62,4 +62,4 @@ private[dtd] abstract class Base {
     final val isNullable = r1.isNullable
     def r = r1
   }
-}
+}

shared/src/main/scala/scala/xml/dtd/impl/PointedHedgeExp.scala renamed to shared/src/main/scala-2.x/scala/xml/dtd/impl/PointedHedgeExp.scala

@@ -32,4 +32,4 @@ private[dtd] abstract class PointedHedgeExp extends Base {
     final val isNullable = false
   }
 
-}
+}

shared/src/main/scala-3.x/scala/xml/dtd/impl/Base.scala

@@ -0,0 +1,68 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2003-2019, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+
+package scala
+package xml.dtd.impl
+
+import scala.annotation.threadUnsafe
+
+/**
+ * Basic regular expressions.
+ *
+ *  @author  Burak Emir
+ */
+
+@deprecated("This class will be removed", "2.10.0")
+private[dtd] abstract class Base {
+  type _regexpT <: RegExp
+
+  abstract class RegExp {
+    // dotty can not override non-lazy val with a lazy val, but an abstract lazy val can not exist in Scala 2
+    lazy val isNullable: Boolean
+  }
+
+  object Alt {
+    /** `Alt( R,R,R* )`. */
+    def apply(rs: _regexpT*) =
+      if (rs.size < 2) throw new SyntaxError("need at least 2 branches in Alt")
+      else new Alt(rs: _*)
+    // Can't enforce that statically without changing the interface
+    // def apply(r1: _regexpT, r2: _regexpT, rs: _regexpT*) = new Alt(Seq(r1, r2) ++ rs: _*)
+    def unapplySeq(x: Alt) = Some(x.rs)
+  }
+
+  class Alt private (val rs: _regexpT*) extends RegExp {
+    @threadUnsafe final lazy val isNullable = rs exists (_.isNullable)
+  }
+
+  object Sequ {
+    /** Sequ( R,R* ) */
+    def apply(rs: _regexpT*) = if (rs.isEmpty) Eps else new Sequ(rs: _*)
+    def unapplySeq(x: Sequ) = Some(x.rs)
+  }
+
+  class Sequ private (val rs: _regexpT*) extends RegExp {
+    @threadUnsafe final lazy val isNullable = rs forall (_.isNullable)
+  }
+
+  case class Star(r: _regexpT) extends RegExp {
+    final lazy val isNullable = true
+  }
+
+  // The empty Sequ.
+  case object Eps extends RegExp {
+    final lazy val isNullable = true
+    override def toString() = "Eps"
+  }
+
+  /** this class can be used to add meta information to regexps. */
+  class Meta(r1: _regexpT) extends RegExp {
+    @threadUnsafe final lazy val isNullable = r1.isNullable
+    def r = r1
+  }
+}

shared/src/main/scala-3.x/scala/xml/dtd/impl/PointedHedgeExp.scala

@@ -0,0 +1,37 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___     Scala API                            **
+**    / __/ __// _ | / /  / _ |    (c) 2003-2019, LAMP/EPFL             **
+**  __\ \/ /__/ __ |/ /__/ __ |    http://scala-lang.org/               **
+** /____/\___/_/ |_/____/_/ | |                                         **
+**                          |/                                          **
+\*                                                                      */
+
+package scala
+package xml.dtd.impl
+
+import scala.annotation.threadUnsafe
+
+/**
+ * Pointed regular hedge expressions, a useful subclass of regular hedge expressions.
+ *
+ *  @author  Burak Emir
+ */
+@deprecated("This class will be removed", "2.10.0")
+private[dtd] abstract class PointedHedgeExp extends Base {
+
+  type _regexpT <: RegExp
+  type _labelT
+
+  case class Node(label: _labelT, r: _regexpT) extends RegExp {
+    @threadUnsafe final lazy val isNullable = false
+  }
+
+  case class TopIter(r1: _regexpT, r2: _regexpT) extends RegExp {
+    @threadUnsafe final lazy val isNullable = r1.isNullable && r2.isNullable //?
+  }
+
+  case object Point extends RegExp {
+    @threadUnsafe final lazy val isNullable = false
+  }
+
+}

shared/src/main/scala/scala/xml/dtd/Scanner.scala

@@ -81,7 +81,11 @@ class Scanner extends Tokens with parsing.TokenTests {
 
   final def name = {
     val sb = new StringBuilder()
-    do { sb.append(c); next() } while (isNameChar(c))
+    while ({
+      sb.append(c)
+      next()
+      isNameChar(c)
+    }) ()
     value = sb.toString()
     NAME
   }

shared/src/main/scala/scala/xml/dtd/impl/WordExp.scala

@@ -53,4 +53,4 @@ private[dtd] abstract class WordExp extends Base {
     final lazy val isNullable = false
     var pos = -1
   }
-}
+}