WIP update to Scala 2.13.1

Author: kiroco12

project/ProjectPlugin.scala

@@ -19,7 +19,7 @@ object ProjectPlugin extends AutoPlugin {
   object autoImport {
 
     object V {
-      lazy val http4s      = "0.20.15"
+      lazy val http4s      = "0.21.0-M6"
       lazy val circe       = "0.12.3"
       lazy val log4s       = "1.7.0"
       lazy val scalatest   = "3.1.0"
@@ -54,18 +54,7 @@ object ProjectPlugin extends AutoPlugin {
       Seq(
         libraryDependencies += "org.scala-lang" % "scala-compiler" % scalaVersion.value,
         libraryDependencies += "org.scala-lang" % "scala-reflect"  % scalaVersion.value,
-        libraryDependencies += compilerPlugin(%%("paradise") cross CrossVersion.full),
-        libraryDependencies ++= {
-          CrossVersion.partialVersion(scalaVersion.value) match {
-            // if scala 2.11+ is used, quasiquotes are merged into scala-reflect
-            case Some((2, scalaMajor)) if scalaMajor >= 11 => Seq()
-            // in Scala 2.10, quasiquotes are provided by macro paradise
-            case Some((2, 10)) =>
-              Seq(
-                %%("quasiquotes") cross CrossVersion.binary
-              )
-          }
-        }
+        scalacOptions += "-Ymacro-annotations"
       )
     }
 
@@ -123,10 +112,9 @@ object ProjectPlugin extends AutoPlugin {
         organizationEmail = "[email protected]"
       ),
       orgLicenseSetting := ApacheLicense,
-      scalaVersion := "2.12.10",
+      scalaVersion := "2.13.1",
       scalaOrganization := "org.scala-lang",
       javacOptions ++= Seq("-encoding", "UTF-8", "-Xlint:-options"),
-      scalacOptions += "-Ypartial-unification",
       fork in Test := false,
       parallelExecution in Test := false,
       cancelable in Global := true,

server/src/main/scala/org/scalaexercises/evaluator/auth.scala

@@ -10,7 +10,7 @@ package org.scalaexercises.evaluator
 import cats.effect.Sync
 import com.typesafe.config._
 import org.http4s._
-import org.http4s.syntax.kleisli.http4sKleisliResponseSyntax
+import org.http4s.syntax.kleisli._
 import org.http4s.util._
 import org.log4s.getLogger
 import pdi.jwt.{Jwt, JwtAlgorithm}

server/src/main/scala/org/scalaexercises/evaluator/evaluation.scala

@@ -13,15 +13,16 @@ import java.net.URLClassLoader
 import java.security.MessageDigest
 import java.util.jar.JarFile
 
-import cats.effect.{Concurrent, ConcurrentEffect, Timer}
+import cats.effect.syntax.concurrent.catsEffectSyntaxConcurrent
+import cats.effect.{ConcurrentEffect, Timer}
 import cats.implicits._
 import coursier._
 import coursier.cache.{ArtifactError, FileCache}
 import coursier.util.Sync
 import org.scalaexercises.evaluator.Eval.CompilerException
+import org.scalaexercises.evaluator.{Dependency => EvaluatorDependency}
 
 import scala.concurrent.duration._
-import scala.language.reflectiveCalls
 import scala.reflect.internal.util.{AbstractFileClassLoader, BatchSourceFile, Position}
 import scala.tools.nsc.io.{AbstractFile, VirtualDirectory}
 import scala.tools.nsc.reporters._
@@ -41,7 +42,7 @@ class Evaluator[F[_]: Sync](timeout: FiniteDuration = 20.seconds)(
 
   def remoteToRepository(remote: Remote): Repository = MavenRepository(remote)
 
-  def dependencyToModule(dependency: Dependency): coursier.Dependency = {
+  def dependencyToModule(dependency: EvaluatorDependency): Dependency = {
     val exclusions: Set[(Organization, ModuleName)] =
       dependency.exclusions
         .fold(List[(Organization, ModuleName)]())(
@@ -60,7 +61,9 @@ class Evaluator[F[_]: Sync](timeout: FiniteDuration = 20.seconds)(
 
   val cache: FileCache[F] = FileCache[F].noCredentials
 
-  def resolveArtifacts(remotes: Seq[Remote], dependencies: Seq[Dependency]): F[Resolution] = {
+  def resolveArtifacts(
+      remotes: Seq[Remote],
+      dependencies: Seq[EvaluatorDependency]): F[Resolution] = {
     Resolve[F](cache)
       .addDependencies(dependencies.map(dependencyToModule): _*)
       .addRepositories(remotes.map(remoteToRepository): _*)
@@ -70,7 +73,7 @@ class Evaluator[F[_]: Sync](timeout: FiniteDuration = 20.seconds)(
 
   def fetchArtifacts(
       remotes: Seq[Remote],
-      dependencies: Seq[Dependency]): F[Either[ArtifactError, List[File]]] =
+      dependencies: Seq[EvaluatorDependency]): F[Either[ArtifactError, List[File]]] =
     for {
       resolution        <- resolveArtifacts(remotes, dependencies)
       gatheredArtifacts <- resolution.artifacts().toList.traverse(cache.file(_).run)
@@ -96,11 +99,12 @@ class Evaluator[F[_]: Sync](timeout: FiniteDuration = 20.seconds)(
         }
       }
 
-      override lazy val compilerMessageHandler: Option[Reporter] = Some(new AbstractReporter {
-        override val settings: Settings    = compilerSettings
-        override def displayPrompt(): Unit = ()
-        override def display(pos: Position, msg: String, severity: this.type#Severity): Unit =
+      override lazy val compilerMessageHandler: Option[Reporter] = Some(new FilteringReporter {
+        override def settings: Settings = compilerSettings
+
+        override def doReport(pos: Position, msg: String, severity: Severity): Unit =
           errors += convert((pos, msg, severity.toString))
+
         override def reset() = {
           super.reset()
           errors = Map.empty
@@ -117,20 +121,20 @@ class Evaluator[F[_]: Sync](timeout: FiniteDuration = 20.seconds)(
     Console.withOut(outCapture) {
 
       val result = for {
-        _      ← Try(eval.check(code))
-        result ← Try(eval.execute[T](code, resetState = true, jars = jars))
+        _      <- Try(eval.check(code))
+        result <- Try(eval.execute[T](code, resetState = true, jars = jars))
       } yield result
 
       val errors = eval.errors
 
       result match {
-        case scala.util.Success(r) ⇒ EvalSuccess[T](errors, r, outCapture.toString)
-        case scala.util.Failure(t) ⇒
+        case scala.util.Success(r) => EvalSuccess[T](errors, r, outCapture.toString)
+        case scala.util.Failure(t) =>
           t match {
-            case e: CompilerException ⇒ CompilationError(errors)
-            case NonFatal(e) ⇒
+            case e: CompilerException => CompilationError(errors)
+            case NonFatal(e) =>
               EvalRuntimeError(errors, Option(RuntimeError(e, None)))
-            case e ⇒ GeneralError(e)
+            case e => GeneralError(e)
           }
       }
     }
@@ -139,25 +143,18 @@ class Evaluator[F[_]: Sync](timeout: FiniteDuration = 20.seconds)(
   def eval[T](
       code: String,
       remotes: Seq[Remote] = Nil,
-      dependencies: Seq[Dependency] = Nil
+      dependencies: Seq[EvaluatorDependency] = Nil
   ): F[EvalResult[T]] = {
     for {
       allJars <- fetchArtifacts(remotes, dependencies)
       result <- allJars match {
         case Right(jars) =>
-          timeoutTo[EvalResult[T]](F.delay { evaluate(code, jars) }, timeout, Timeout[T](timeout))
+          F.delay[EvalResult[T]](evaluate(code, jars))
+            .timeoutTo(timeout, Timeout[T](timeout).asInstanceOf[EvalResult[T]].pure[F])
         case Left(fileError) => F.pure(UnresolvedDependency[T](fileError.describe))
       }
     } yield result
   }
-
-  def timeoutTo[A](fa: F[A], after: FiniteDuration, fallback: A): F[A] = {
-
-    Concurrent[F].race(fa, T.sleep(after)).flatMap {
-      case Left(a)  => a.pure[F]
-      case Right(_) => fallback.pure[F]
-    }
-  }
 }
 
 /**
@@ -181,15 +178,15 @@ private class StringCompiler(
   val cache = new scala.collection.mutable.HashMap[String, Class[_]]()
 
   trait MessageCollector {
-    val messages: Seq[List[String]]
+    val messages: scala.collection.mutable.ListBuffer[List[String]]
   }
 
-  val reporter = messageHandler getOrElse new AbstractReporter with MessageCollector {
+  val reporter = messageHandler getOrElse new FilteringReporter with MessageCollector {
     val settings = StringCompiler.this.settings
     val messages = new scala.collection.mutable.ListBuffer[List[String]]
 
-    def display(pos: Position, message: String, severity: Severity) = {
-      severity.count += 1
+    def doReport(pos: Position, message: String, severity: Severity) = {
+      increment(severity)
       val severityName = severity match {
         case ERROR   => "error: "
         case WARNING => "warning: "
@@ -211,10 +208,6 @@ private class StringCompiler(
        })
     }
 
-    def displayPrompt = {
-      // no.
-    }
-
     override def reset = {
       super.reset
       messages.clear()
@@ -264,7 +257,7 @@ private class StringCompiler(
     // ...and 1/2 this line:
     compiler.compileSources(sourceFiles)
 
-    if (reporter.hasErrors || reporter.WARNING.count > 0) {
+    if (reporter.hasErrors || reporter.hasWarnings) {
       val msgs: List[List[String]] = reporter match {
         case collector: MessageCollector =>
           collector.messages.toList

server/src/main/scala/org/scalaexercises/evaluator/services.scala

@@ -17,19 +17,18 @@ import org.http4s._
 import org.http4s.dsl._
 import org.http4s.headers.Allow
 import org.http4s.server.blaze._
-import org.http4s.syntax.kleisli.http4sKleisliResponseSyntax
+import org.http4s.syntax.kleisli.http4sKleisliResponseSyntaxOptionT
 import org.log4s.getLogger
 import org.scalaexercises.evaluator.codecs._
 
 import scala.concurrent.duration._
-import scala.language.postfixOps
 
 object services {
 
   import EvalResponse.messages._
 
-  def evaluatorInstance[F[_]: ConcurrentEffect: ContextShift: Timer: Sync] =
-    new Evaluator[F](20 seconds)
+  //def evaluatorInstance[F[_]: ConcurrentEffect: ContextShift: Timer: Sync] =
+  //  new Evaluator[F](20 seconds)
 
   val corsHeaders = Seq(
     Header("Vary", "Origin,Access-Control-Request-Methods"),
@@ -116,12 +115,14 @@ object EvaluatorServer extends IOApp {
   lazy val port = (Option(System.getenv("PORT")) orElse
     Option(System.getProperty("http.port"))).map(_.toInt).getOrElse(8080)
 
+  val evaluator = new Evaluator[IO](10.seconds)
+
   override def run(args: List[String]): IO[ExitCode] = {
     logger.info(s"Initializing Evaluator at $ip:$port")
 
     BlazeServerBuilder[IO]
       .bindHttp(port, ip)
-      .withHttpApp(auth[IO](service(evaluatorInstance)))
+      .withHttpApp(auth[IO](service(evaluator)))
       .serve
       .compile
       .lastOrError

server/src/test/scala/org/scalaexercises/evaluator/EvaluatorSpec.scala

@@ -26,7 +26,7 @@ class EvaluatorSpec extends AnyFunSpec with Matchers with Implicits {
         .unsafeRunSync()
 
       result should matchPattern {
-        case EvalSuccess(_, 42, _) ⇒
+        case EvalSuccess(_, 42, _) =>
       }
     }
 
@@ -36,7 +36,7 @@ class EvaluatorSpec extends AnyFunSpec with Matchers with Implicits {
         .unsafeRunSync()
 
       result should matchPattern {
-        case EvalSuccess(_, 42, _) ⇒
+        case EvalSuccess(_, 42, _) =>
       }
     }
 
@@ -49,7 +49,7 @@ class EvaluatorSpec extends AnyFunSpec with Matchers with Implicits {
         .unsafeRunSync()
 
       result should matchPattern {
-        case Timeout(_) ⇒
+        case Timeout(_) =>
       }
     }
 
@@ -69,7 +69,7 @@ Xor.Right(42).toOption.get
         .eval(
           code,
           remotes = remotes,
-          dependencies = dependencies
+          dependencies = scalaDependencies(Scala211) ++ dependencies
         )
         .unsafeRunSync()