Support for scala 2.13.0-M5

akka-http-caching/src/main/mima-filters/10.1.7.backwards.excludes

@@ -0,0 +1,2 @@
+# Scala 2.13.0-M5
+ProblemFilters.exclude[MissingTypesProblem]("akka.http.caching.scaladsl.CachingSettings$")

akka-http-caching/src/main/scala/akka/http/caching/LfuCache.scala

@@ -38,7 +38,7 @@ object LfuCache {
     require(settings.maxCapacity >= 0, "maxCapacity must not be negative")
     require(settings.initialCapacity <= settings.maxCapacity, "initialCapacity must be <= maxCapacity")
 
-    if (settings.timeToLive.isFinite() || settings.timeToIdle.isFinite()) expiringLfuCache(settings.maxCapacity, settings.initialCapacity, settings.timeToLive, settings.timeToIdle)
+    if (settings.timeToLive.isFinite || settings.timeToIdle.isFinite) expiringLfuCache(settings.maxCapacity, settings.initialCapacity, settings.timeToLive, settings.timeToIdle)
     else simpleLfuCache(settings.maxCapacity, settings.initialCapacity)
   }
 

akka-http-caching/src/main/scala/akka/http/caching/scaladsl/CachingSettings.scala

@@ -6,7 +6,7 @@ package akka.http.caching.scaladsl
 
 import akka.annotation.{ DoNotInherit, InternalApi }
 import akka.http.caching.javadsl
-import akka.http.impl.util.SettingsCompanion
+import akka.http.impl.util.SettingsCompanionImpl
 import com.typesafe.config.Config
 
 import scala.concurrent.duration.Duration
@@ -62,7 +62,7 @@ private[http] final case class LfuCacheSettingsImpl(
   override def productPrefix = "LfuCacheSettings"
 }
 
-object CachingSettings extends SettingsCompanion[CachingSettings]("akka.http.caching") {
+object CachingSettings extends SettingsCompanionImpl[CachingSettings]("akka.http.caching") {
   def fromSubConfig(root: Config, c: Config): CachingSettingsImpl = {
     val lfuConfig = c.getConfig("lfu-cache")
     CachingSettingsImpl(

akka-http-core/src/main/java/akka/http/impl/util/Util.java

@@ -9,6 +9,7 @@
 import scala.collection.immutable.Map$;
 import scala.collection.immutable.Seq;
 import akka.stream.scaladsl.Source;
+import akka.http.ccompat.MapHelpers;
 
 import java.util.Arrays;
 import java.util.Map;
@@ -35,7 +36,7 @@ public static <T, U extends T> Source<U, scala.Unit> upcastSource(Source<T, scal
         return (Source<U, scala.Unit>)(Object) p;
     }
     public static scala.collection.immutable.Map<String, String> convertMapToScala(Map<String, String> map) {
-        return emptyMap.$plus$plus(scala.collection.JavaConverters.mapAsScalaMapConverter(map).asScala());
+        return MapHelpers.convertMapToScala(map);
     }
     @SuppressWarnings("unchecked") // contains an upcast
     public static <T, U extends T> scala.Option<U> convertOptionalToScala(Optional<T> o) {

akka-http-core/src/main/java/akka/http/javadsl/model/Multiparts.java

@@ -12,9 +12,10 @@
 import java.util.Collections;
 import java.util.Map;
 
+import akka.http.ccompat.MapHelpers;
+
 import static akka.http.impl.util.Util.convertArray;
 import static akka.http.impl.util.Util.convertMapToScala;
-import static akka.http.impl.util.Util.emptyMap;
 
 /**
  * Constructors for Multipart instances
@@ -140,7 +141,7 @@ public static Multipart.FormData.BodyPart.Strict createFormDataBodyPartStrict(St
     }
 
     private static scala.collection.immutable.Map<String, HttpEntity.Strict> toScalaMap(Map<String, HttpEntity.Strict> map) {
-        return emptyMap.$plus$plus(scala.collection.JavaConverters.mapAsScalaMapConverter(map).asScala());
+        return MapHelpers.convertMapToScala(map);
     }
 
     private static scala.collection.Iterable<HttpHeader> toScalaSeq(java.util.List<HttpHeader> _headers) {

akka-http-core/src/main/mima-filters/10.1.7.backwards.excludes

@@ -0,0 +1,10 @@
+# 2.13.0-M5 support:
+ProblemFilters.exclude[MissingClassProblem]("akka.http.impl.util.SettingsCompanion")
+ProblemFilters.exclude[MissingClassProblem]("akka.http.impl.util.SettingsCompanion$")
+ProblemFilters.exclude[MissingTypesProblem]("akka.http.impl.settings.ConnectionPoolSettingsImpl$")
+ProblemFilters.exclude[MissingTypesProblem]("akka.http.impl.settings.HttpsProxySettingsImpl$")
+ProblemFilters.exclude[MissingTypesProblem]("akka.http.impl.settings.ParserSettingsImpl$")
+ProblemFilters.exclude[MissingTypesProblem]("akka.http.impl.settings.ServerSettingsImpl$")
+ProblemFilters.exclude[MissingTypesProblem]("akka.http.impl.settings.PreviewServerSettingsImpl$")
+ProblemFilters.exclude[MissingTypesProblem]("akka.http.impl.settings.ClientConnectionSettingsImpl$")
+ProblemFilters.exclude[MissingTypesProblem]("akka.http.scaladsl.settings.Http2ServerSettings$Http2ServerSettingsImpl$")

akka-http-core/src/main/scala-2.13+/akka/http/ccompat/MapHelpers.scala

@@ -0,0 +1,12 @@
+/*
+ * Copyright (C) 2018-2019 Lightbend Inc. <https://www.lightbend.com>
+ */
+
+package akka.http.ccompat
+
+object MapHelpers {
+  def convertMapToScala[K, V](jmap: java.util.Map[K, V]): scala.collection.immutable.Map[K, V] = {
+    import scala.collection.JavaConverters._
+    Map.empty.concat(jmap.asScala)
+  }
+}

akka-http-core/src/main/scala-2.13+/akka/http/ccompat/imm/package.scala

@@ -0,0 +1,14 @@
+/*
+ * Copyright (C) 2018-2019 Lightbend Inc. <https://www.lightbend.com>
+ */
+
+package akka.http.ccompat
+
+import scala.collection.immutable
+
+/**
+ * INTERNAL API
+ */
+package object imm {
+  // Nothing yet, but present to be source-compatible with 2.13-
+}

akka-http-core/src/main/scala-2.13+/akka/http/ccompat/package.scala

@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2018-2019 Lightbend Inc. <https://www.lightbend.com>
+ */
+
+package akka.http
+
+/**
+ * INTERNAL API
+ */
+package object ccompat {
+
+  type Builder[-A, +To] = scala.collection.mutable.Builder[A, To]
+}
+
+/**
+ * INTERNAL API
+ */
+package ccompat {
+  import akka.http.scaladsl.model.Uri.Query
+  trait QuerySeqOptimized extends scala.collection.immutable.LinearSeq[(String, String)] with scala.collection.StrictOptimizedLinearSeqOps[(String, String), scala.collection.immutable.LinearSeq, Query] {
+    override protected def fromSpecific(coll: IterableOnce[(String, String)]): Query =
+      Query(coll.iterator.to(Seq): _*)
+
+    def newBuilder: Any = akka.http.scaladsl.model.Uri.Query.newBuilder
+  }
+}

akka-http-core/src/main/scala-2.13+/akka/http/scaladsl/util/FastFuture.scala

@@ -0,0 +1,124 @@
+/*
+ * Copyright (C) 2009-2019 Lightbend Inc. <https://www.lightbend.com>
+ */
+
+package akka.http.scaladsl.util
+
+import scala.language.higherKinds
+import scala.util.control.NonFatal
+import scala.util.{ Failure, Success, Try }
+import scala.collection.BuildFrom
+import scala.concurrent.duration.Duration
+import scala.concurrent._
+
+/**
+ * Provides alternative implementations of the basic transformation operations defined on [[scala.concurrent.Future]],
+ * which try to avoid scheduling to an [[scala.concurrent.ExecutionContext]] if possible, i.e. if the given future
+ * value is already present.
+ */
+class FastFuture[A](val future: Future[A]) extends AnyVal {
+  import FastFuture._
+
+  def map[B](f: A ⇒ B)(implicit ec: ExecutionContext): Future[B] =
+    transformWith(a ⇒ FastFuture.successful(f(a)), FastFuture.failed)
+
+  def flatMap[B](f: A ⇒ Future[B])(implicit ec: ExecutionContext): Future[B] =
+    transformWith(f, FastFuture.failed)
+
+  def filter(pred: A ⇒ Boolean)(implicit executor: ExecutionContext): Future[A] =
+    flatMap { r ⇒
+      if (pred(r)) future
+      else throw new NoSuchElementException("Future.filter predicate is not satisfied")
+    }
+
+  def foreach(f: A ⇒ Unit)(implicit ec: ExecutionContext): Unit = map(f)
+
+  def transformWith[B](f: Try[A] ⇒ Future[B])(implicit executor: ExecutionContext): Future[B] =
+    transformWith(a ⇒ f(Success(a)), e ⇒ f(Failure(e)))
+
+  def transformWith[B](s: A ⇒ Future[B], f: Throwable ⇒ Future[B])(implicit executor: ExecutionContext): Future[B] = {
+    def strictTransform[T](x: T, f: T ⇒ Future[B]) =
+      try f(x)
+      catch { case NonFatal(e) ⇒ ErrorFuture(e) }
+
+    future match {
+      case FulfilledFuture(a) ⇒ strictTransform(a, s)
+      case ErrorFuture(e)     ⇒ strictTransform(e, f)
+      case _ ⇒ future.value match {
+        case None ⇒
+          val p = Promise[B]()
+          future.onComplete {
+            case Success(a) ⇒ p completeWith strictTransform(a, s)
+            case Failure(e) ⇒ p completeWith strictTransform(e, f)
+          }
+          p.future
+        case Some(Success(a)) ⇒ strictTransform(a, s)
+        case Some(Failure(e)) ⇒ strictTransform(e, f)
+      }
+    }
+  }
+
+  def recover[B >: A](pf: PartialFunction[Throwable, B])(implicit ec: ExecutionContext): Future[B] =
+    transformWith(FastFuture.successful, t ⇒ if (pf isDefinedAt t) FastFuture.successful(pf(t)) else future)
+
+  def recoverWith[B >: A](pf: PartialFunction[Throwable, Future[B]])(implicit ec: ExecutionContext): Future[B] =
+    transformWith(FastFuture.successful, t ⇒ pf.applyOrElse(t, (_: Throwable) ⇒ future))
+}
+
+object FastFuture {
+  def apply[T](value: Try[T]): Future[T] = value match {
+    case Success(t) ⇒ FulfilledFuture(t)
+    case Failure(e) ⇒ ErrorFuture(e)
+  }
+  private[this] val _successful: Any ⇒ Future[Any] = FulfilledFuture.apply
+  def successful[T]: T ⇒ Future[T] = _successful.asInstanceOf[T ⇒ Future[T]]
+  val failed: Throwable ⇒ Future[Nothing] = ErrorFuture.apply
+
+  private case class FulfilledFuture[+A](a: A) extends Future[A] {
+    def value = Some(Success(a))
+    def onComplete[U](f: Try[A] ⇒ U)(implicit executor: ExecutionContext) = Future.successful(a).onComplete(f)
+    def isCompleted = true
+    def result(atMost: Duration)(implicit permit: CanAwait) = a
+    def ready(atMost: Duration)(implicit permit: CanAwait) = this
+    def transform[S](f: scala.util.Try[A] ⇒ scala.util.Try[S])(implicit executor: scala.concurrent.ExecutionContext): scala.concurrent.Future[S] =
+      FastFuture(f(Success(a)))
+    def transformWith[S](f: scala.util.Try[A] ⇒ scala.concurrent.Future[S])(implicit executor: scala.concurrent.ExecutionContext): scala.concurrent.Future[S] =
+      new FastFuture(this).transformWith(f)
+  }
+  private case class ErrorFuture(error: Throwable) extends Future[Nothing] {
+    def value = Some(Failure(error))
+    def onComplete[U](f: Try[Nothing] ⇒ U)(implicit executor: ExecutionContext) = Future.failed(error).onComplete(f)
+    def isCompleted = true
+    def result(atMost: Duration)(implicit permit: CanAwait) = throw error
+    def ready(atMost: Duration)(implicit permit: CanAwait) = this
+    def transform[S](f: scala.util.Try[Nothing] ⇒ scala.util.Try[S])(implicit executor: scala.concurrent.ExecutionContext): scala.concurrent.Future[S] =
+      FastFuture(f(Failure(error)))
+    def transformWith[S](f: scala.util.Try[Nothing] ⇒ scala.concurrent.Future[S])(implicit executor: scala.concurrent.ExecutionContext): scala.concurrent.Future[S] =
+      new FastFuture(this).transformWith(f)
+  }
+
+  implicit class EnhancedFuture[T](val future: Future[T]) extends AnyVal {
+    def fast: FastFuture[T] = new FastFuture[T](future)
+  }
+
+  def sequence[T, M[_] <: IterableOnce[_]](in: M[Future[T]])(implicit cbf: BuildFrom[M[Future[T]], T, M[T]], executor: ExecutionContext): Future[M[T]] =
+    in.iterator.foldLeft(successful(cbf.newBuilder(in))) {
+      (fr, fa) ⇒ for (r ← fr.fast; a ← fa.asInstanceOf[Future[T]].fast) yield r += a
+    }.fast.map(_.result())
+
+  /* FIXME
+  def fold[T, R](futures: IterableOnce[Future[T]])(zero: R)(f: (R, T) ⇒ R)(implicit executor: ExecutionContext): Future[R] =
+    if (futures.isEmpty) successful(zero)
+    else sequence(futures).fast.map(_.foldLeft(zero)(f))
+
+  def reduce[T, R >: T](futures: IterableOnce[Future[T]])(op: (R, T) ⇒ R)(implicit executor: ExecutionContext): Future[R] =
+    if (futures.isEmpty) failed(new NoSuchElementException("reduce attempted on empty collection"))
+    else sequence(futures).fast.map(_ reduceLeft op)
+*/
+
+  def traverse[A, B, M[_] <: IterableOnce[_]](in: M[A])(fn: A ⇒ Future[B])(implicit cbf: BuildFrom[M[A], B, M[B]], executor: ExecutionContext): Future[M[B]] =
+    in.iterator.foldLeft(successful(cbf.newBuilder(in))) { (fr, a) ⇒
+      val fb = fn(a.asInstanceOf[A])
+      for (r ← fr.fast; b ← fb.fast) yield r += b
+    }.fast.map(_.result())
+}

akka-http-core/src/main/scala-2.13-/akka/http/ccompat/CompatImpl.scala

@@ -0,0 +1,22 @@
+/*
+ * Copyright (C) 2019 Lightbend Inc. <https://www.lightbend.com>
+ */
+
+package akka.http.ccompat
+
+import scala.collection.generic.CanBuildFrom
+import scala.collection.mutable
+
+/**
+ * INTERNAL API
+ *
+ * Based on https://github.com/scala/scala-collection-compat/blob/master/compat/src/main/scala-2.11_2.12/scala/collection/compat/CompatImpl.scala
+ * but reproduced here so we don't need to add a dependency on this library. It contains much more than we need right now, and is
+ * not promising binary compatibility yet at the time of writing.
+ */
+private[ccompat] object CompatImpl {
+  def simpleCBF[A, C](f: ⇒ mutable.Builder[A, C]): CanBuildFrom[Any, A, C] = new CanBuildFrom[Any, A, C] {
+    def apply(from: Any): mutable.Builder[A, C] = apply()
+    def apply(): mutable.Builder[A, C] = f
+  }
+}

akka-http-core/src/main/scala-2.13-/akka/http/ccompat/MapHelpers.scala

@@ -0,0 +1,15 @@
+/*
+ * Copyright (C) 2018-2019 Lightbend Inc. <https://www.lightbend.com>
+ */
+
+package akka.http.ccompat
+
+/**
+ * INTERNAL API
+ */
+object MapHelpers {
+  def convertMapToScala[K, V](jmap: java.util.Map[K, V]): scala.collection.immutable.Map[K, V] = {
+    import scala.collection.JavaConverters._
+    Map.empty ++ jmap.asScala
+  }
+}

akka-http-core/src/main/scala-2.13-/akka/http/ccompat/imm/package.scala

@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2018-2019 Lightbend Inc. <https://www.lightbend.com>
+ */
+
+package akka.http.ccompat
+
+import scala.collection.immutable
+
+/**
+ * INTERNAL API
+ */
+package object imm {
+  implicit class SortedSetOps[A](val real: immutable.SortedSet[A]) extends AnyVal {
+    def unsorted: immutable.Set[A] = real
+  }
+
+  implicit class StreamOps[A](val underlying: immutable.Stream[A]) extends AnyVal {
+    // renamed in 2.13
+    def lazyAppendedAll[B >: A](rest: ⇒ TraversableOnce[B]): Stream[B] = underlying.append(rest)
+  }
+}

akka-http-core/src/main/scala-2.13-/akka/http/ccompat/package.scala

@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2018-2019 Lightbend Inc. <https://www.lightbend.com>
+ */
+
+package akka.http
+
+import scala.collection.generic.{ CanBuildFrom, GenericCompanion }
+import scala.collection.{ GenTraversable, mutable }
+import scala.{ collection ⇒ c }
+
+/**
+ * INTERNAL API
+ *
+ * Partly based on https://github.com/scala/scala-collection-compat/blob/master/compat/src/main/scala-2.11_2.12/scala/collection/compat/PackageShared.scala
+ * but reproduced here so we don't need to add a dependency on this library. It contains much more than we need right now, and is
+ * not promising binary compatibility yet at the time of writing.
+ */
+package object ccompat {
+  import CompatImpl._
+
+  implicit def genericCompanionToCBF[A, CC[X] <: GenTraversable[X]](
+    fact: GenericCompanion[CC]): CanBuildFrom[Any, A, CC[A]] =
+    simpleCBF(fact.newBuilder[A])
+
+  // This really belongs into scala.collection but there's already a package object
+  // in scala-library so we can't add to it
+  type IterableOnce[+X] = c.TraversableOnce[X]
+  val IterableOnce = c.TraversableOnce
+}
+
+/**
+ * INTERNAL API
+ */
+package ccompat {
+  trait Builder[-Elem, +To] extends mutable.Builder[Elem, To] { self ⇒
+    // This became final in 2.13 so cannot be overridden there anymore
+    final override def +=(elem: Elem): this.type = addOne(elem)
+    def addOne(elem: Elem): this.type = self.+=(elem)
+  }
+
+  trait QuerySeqOptimized extends scala.collection.immutable.LinearSeq[(String, String)] with scala.collection.LinearSeqOptimized[(String, String), akka.http.scaladsl.model.Uri.Query] {
+    self: akka.http.scaladsl.model.Uri.Query ⇒
+    override def newBuilder: mutable.Builder[(String, String), akka.http.scaladsl.model.Uri.Query] = akka.http.scaladsl.model.Uri.Query.newBuilder
+  }
+}

akka-http-core/src/main/scala/akka/http/impl/engine/parsing/HttpHeaderParser.scala

@@ -17,8 +17,9 @@ import akka.http.scaladsl.settings.ParserSettings
 import scala.annotation.tailrec
 import akka.parboiled2.CharUtils
 import akka.util.ByteString
+import akka.http.ccompat._
 import akka.http.impl.util._
-import akka.http.scaladsl.model._
+import akka.http.scaladsl.model.{ ErrorInfo, HttpHeader, MediaTypes, StatusCode, StatusCodes }
 import akka.http.scaladsl.model.headers.{ EmptyHeader, RawHeader }
 import akka.http.impl.model.parser.HeaderParser
 import akka.http.impl.model.parser.CharacterClasses._
@@ -476,10 +477,10 @@ private[http] object HttpHeaderParser {
 
     val valueParsers: Seq[HeaderValueParser] =
       HeaderParser.ruleNames
-        .filter(headerParserFilter)
+        .filter(headerParserFilter).iterator
         .map { name ⇒
           new ModeledHeaderValueParser(name, parser.settings.maxHeaderValueLength, parser.settings.headerValueCacheLimit(name), parser.log, parser.settings)
-        }(collection.breakOut)
+        }.to(scala.collection.immutable.IndexedSeq)
 
     def insertInGoodOrder(items: Seq[Any])(startIx: Int = 0, endIx: Int = items.size): Unit =
       if (endIx - startIx > 0) {

akka-http-core/src/main/scala/akka/http/impl/engine/parsing/HttpMessageParser.scala

@@ -14,7 +14,7 @@ import akka.parboiled2.CharUtils
 import akka.util.ByteString
 import akka.http.impl.model.parser.CharacterClasses
 import akka.http.scaladsl.settings.ParserSettings
-import akka.http.scaladsl.model._
+import akka.http.scaladsl.model.{ ParsingException ⇒ _, _ }
 import headers._
 import HttpProtocols._
 import ParserOutput._