Cross compiles project to Scala 3

.gitignore

@@ -2,6 +2,7 @@
 lib_managed/
 project/project
 target/
+.bsp
 
 # Worksheets (Eclipse or IntelliJ)
 *.sc

.travis.yml

@@ -6,7 +6,7 @@ scala:
   - 2.11.12
   - 2.12.13
   - 2.13.4
-
+  - 3.0.0-RC1
 env:
   - ADOPTOPENJDK=8
   - ADOPTOPENJDK=11

build.sbt

@@ -9,10 +9,20 @@ scalacOptions ++= Seq(
   "-Ywarn-unused"
 )
 incOptions := incOptions.value.withLogRecompileOnMacro(false)
-libraryDependencies ++= Dependencies.scalaLogging(scalaVersion.value)
+libraryDependencies ++= Dependencies.scalaLogging(scalaVersion.value, isDotty.value)
 initialCommands := """|import com.typesafe.scalalogging._
                       |import org.slf4j.{ Logger => Underlying, _ }""".stripMargin
 
+unmanagedSourceDirectories in Compile ++= {
+  val sourceDir = (sourceDirectory in Compile).value
+  val extraFilesOpt = CrossVersion.partialVersion(scalaVersion.value) match {
+    case Some((2, _)) => Some(sourceDir / "scala-2.x")
+    case Some((3, _)) => Some(sourceDir / "scala-3.x")
+    case _ => None
+  }
+  extraFilesOpt.toSeq
+}
+
 // OSGi
 
 import com.typesafe.sbt.osgi.SbtOsgi

project/Dependencies.scala

@@ -2,27 +2,29 @@ import sbt._
 
 object Version {
   val logback   = "1.2.3"
-  val mockito   = "1.16.23"
-  val scalaTest = "3.2.3"
+  val mockito   = "3.2.4.0"
+  val scalaTest = "3.2.4"
   val slf4j     = "1.7.30"
 }
 
 object Library {
-  val logbackClassic                     = "ch.qos.logback" %  "logback-classic"         % Version.logback
-  val mockitoScala                       = "org.mockito"    %% "mockito-scala-scalatest" % Version.mockito
-  def scalaReflect(scalaVersion: String) = "org.scala-lang" %  "scala-reflect"           % scalaVersion
-  val scalaTest                          = "org.scalatest"  %% "scalatest"               % Version.scalaTest
-  val slf4jApi                           = "org.slf4j"      %  "slf4j-api"               % Version.slf4j
+  val logbackClassic                     = "ch.qos.logback"    %  "logback-classic" % Version.logback
+  val mockitoScala                       = "org.scalatestplus" %% "mockito-3-4"     % Version.mockito
+  def scalaReflect(scalaVersion: String) = "org.scala-lang"    %  "scala-reflect"   % scalaVersion
+  val scalaTest                          = "org.scalatest"     %% "scalatest"       % Version.scalaTest
+  val slf4jApi                           = "org.slf4j"         %  "slf4j-api"       % Version.slf4j
 }
 
 object Dependencies {
   import Library._
 
-  def scalaLogging(scalaVersion: String) = List(
-    scalaReflect(scalaVersion),
-    slf4jApi,
-    logbackClassic % "test",
-    mockitoScala   % "test",
-    scalaTest      % "test"
-  )
+  def scalaLogging(scalaVersion: String, isDotty: Boolean) = {
+    List(scalaReflect(scalaVersion)).filter(_ => !isDotty) ++
+      List(
+        slf4jApi,
+        logbackClassic % "test",
+        mockitoScala   % "test",
+        scalaTest      % "test"
+      )
+  }
 }

project/plugins.sbt

@@ -3,3 +3,4 @@ addSbtPlugin("com.typesafe.sbt" % "sbt-osgi" % "0.9.6")
 addSbtPlugin("com.scalapenos" % "sbt-prompt" % "1.0.2")
 addSbtPlugin("com.geirsson" % "sbt-ci-release" % "1.5.5")
 addSbtPlugin("com.dwijnand" % "sbt-travisci" % "1.2.0")
+addSbtPlugin("ch.epfl.lamp" % "sbt-dotty" % "0.5.3")

src/main/scala-2.x/com/typesafe/scalalogging/LoggerImpl.scala

@@ -0,0 +1,85 @@
+package com.typesafe.scalalogging
+
+import org.slf4j.Marker
+class LoggerImpl {
+
+  // Error
+
+  def error(message: String): Unit = macro LoggerMacro.errorMessage
+
+  def error(message: String, cause: Throwable): Unit = macro LoggerMacro.errorMessageCause
+
+  def error(message: String, args: Any*): Unit = macro LoggerMacro.errorMessageArgs
+
+  def error(marker: Marker, message: String): Unit = macro LoggerMacro.errorMessageMarker
+
+  def error(marker: Marker, message: String, cause: Throwable): Unit = macro LoggerMacro.errorMessageCauseMarker
+
+  def error(marker: Marker, message: String, args: Any*): Unit = macro LoggerMacro.errorMessageArgsMarker
+
+  def whenErrorEnabled(body: Unit): Unit = macro LoggerMacro.errorCode
+
+  // Warn
+
+  def warn(message: String): Unit = macro LoggerMacro.warnMessage
+
+  def warn(message: String, cause: Throwable): Unit = macro LoggerMacro.warnMessageCause
+
+  def warn(message: String, args: Any*): Unit = macro LoggerMacro.warnMessageArgs
+
+  def warn(marker: Marker, message: String): Unit = macro LoggerMacro.warnMessageMarker
+
+  def warn(marker: Marker, message: String, cause: Throwable): Unit = macro LoggerMacro.warnMessageCauseMarker
+
+  def warn(marker: Marker, message: String, args: Any*): Unit = macro LoggerMacro.warnMessageArgsMarker
+
+  def whenWarnEnabled(body: Unit): Unit = macro LoggerMacro.warnCode
+
+  // Info
+
+  def info(message: String): Unit = macro LoggerMacro.infoMessage
+
+  def info(message: String, cause: Throwable): Unit = macro LoggerMacro.infoMessageCause
+
+  def info(message: String, args: Any*): Unit = macro LoggerMacro.infoMessageArgs
+
+  def info(marker: Marker, message: String): Unit = macro LoggerMacro.infoMessageMarker
+
+  def info(marker: Marker, message: String, cause: Throwable): Unit = macro LoggerMacro.infoMessageCauseMarker
+
+  def info(marker: Marker, message: String, args: Any*): Unit = macro LoggerMacro.infoMessageArgsMarker
+
+  def whenInfoEnabled(body: Unit): Unit = macro LoggerMacro.infoCode
+
+  // Debug
+
+  def debug(message: String): Unit = macro LoggerMacro.debugMessage
+
+  def debug(message: String, cause: Throwable): Unit = macro LoggerMacro.debugMessageCause
+
+  def debug(message: String, args: Any*): Unit = macro LoggerMacro.debugMessageArgs
+
+  def debug(marker: Marker, message: String): Unit = macro LoggerMacro.debugMessageMarker
+
+  def debug(marker: Marker, message: String, cause: Throwable): Unit = macro LoggerMacro.debugMessageCauseMarker
+
+  def debug(marker: Marker, message: String, args: Any*): Unit = macro LoggerMacro.debugMessageArgsMarker
+
+  def whenDebugEnabled(body: Unit): Unit = macro LoggerMacro.debugCode
+
+  // Trace
+
+  def trace(message: String): Unit = macro LoggerMacro.traceMessage
+
+  def trace(message: String, cause: Throwable): Unit = macro LoggerMacro.traceMessageCause
+
+  def trace(message: String, args: Any*): Unit = macro LoggerMacro.traceMessageArgs
+
+  def trace(marker: Marker, message: String): Unit = macro LoggerMacro.traceMessageMarker
+
+  def trace(marker: Marker, message: String, cause: Throwable): Unit = macro LoggerMacro.traceMessageCauseMarker
+
+  def trace(marker: Marker, message: String, args: Any*): Unit = macro LoggerMacro.traceMessageArgsMarker
+
+  def whenTraceEnabled(body: Unit): Unit = macro LoggerMacro.traceCode
+}

src/main/scala-2.x/com/typesafe/scalalogging/LoggerTakingImplicitImpl.scala

@@ -0,0 +1,77 @@
+package com.typesafe.scalalogging
+
+import org.slf4j.Marker
+
+class LoggerTakingImplicitImpl[A] private[scalalogging] {
+
+  // Error
+
+  def error(message: String)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.errorMessage[A]
+
+  def error(message: String, cause: Throwable)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.errorMessageCause[A]
+
+  def error(message: String, args: Any*)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.errorMessageArgs[A]
+
+  def error(marker: Marker, message: String)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.errorMessageMarker[A]
+
+  def error(marker: Marker, message: String, cause: Throwable)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.errorMessageCauseMarker[A]
+
+  def error(marker: Marker, message: String, args: Any*)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.errorMessageArgsMarker[A]
+
+  // Warn
+
+  def warn(message: String)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.warnMessage[A]
+
+  def warn(message: String, cause: Throwable)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.warnMessageCause[A]
+
+  def warn(message: String, args: Any*)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.warnMessageArgs[A]
+
+  def warn(marker: Marker, message: String)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.warnMessageMarker[A]
+
+  def warn(marker: Marker, message: String, cause: Throwable)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.warnMessageCauseMarker[A]
+
+  def warn(marker: Marker, message: String, args: Any*)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.warnMessageArgsMarker[A]
+
+  // Info
+
+  def info(message: String)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.infoMessage[A]
+
+  def info(message: String, cause: Throwable)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.infoMessageCause[A]
+
+  def info(message: String, args: Any*)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.infoMessageArgs[A]
+
+  def info(marker: Marker, message: String)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.infoMessageMarker[A]
+
+  def info(marker: Marker, message: String, cause: Throwable)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.infoMessageCauseMarker[A]
+
+  def info(marker: Marker, message: String, args: Any*)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.infoMessageArgsMarker[A]
+
+  // Debug
+
+  def debug(message: String)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.debugMessage[A]
+
+  def debug(message: String, cause: Throwable)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.debugMessageCause[A]
+
+  def debug(message: String, args: Any*)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.debugMessageArgs[A]
+
+  def debug(marker: Marker, message: String)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.debugMessageMarker[A]
+
+  def debug(marker: Marker, message: String, cause: Throwable)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.debugMessageCauseMarker[A]
+
+  def debug(marker: Marker, message: String, args: Any*)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.debugMessageArgsMarker[A]
+
+  // Trace
+
+  def trace(message: String)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.traceMessage[A]
+
+  def trace(message: String, cause: Throwable)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.traceMessageCause[A]
+
+  def trace(message: String, args: Any*)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.traceMessageArgs[A]
+
+  def trace(marker: Marker, message: String)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.traceMessageMarker[A]
+
+  def trace(marker: Marker, message: String, cause: Throwable)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.traceMessageCauseMarker[A]
+
+  def trace(marker: Marker, message: String, args: Any*)(implicit a: A): Unit = macro LoggerTakingImplicitMacro.traceMessageArgsMarker[A]
+
+}

src/main/scala-3.x/com/typesafe/scalalogging/LoggerImpl.scala

@@ -0,0 +1,57 @@
+package com.typesafe.scalalogging
+
+import org.slf4j.{Marker, Logger as Underlying }
+
+trait LoggerImpl {
+  def underlying: Underlying
+
+
+  // Error
+  inline def error(inline message: String): Unit = ${LoggerMacro.errorMessage('underlying, 'message)}
+  inline def error(inline message: String, inline cause: Throwable): Unit = ${LoggerMacro.errorMessageCause('underlying, 'message, 'cause)}
+  inline def error(inline message: String, inline args: Any*): Unit = ${LoggerMacro.errorMessageArgs('underlying, 'message, 'args)}
+  inline def error(inline marker: Marker, inline message: String): Unit = ${LoggerMacro.errorMessageMarker('underlying, 'marker, 'message)}
+  inline def error(inline marker: Marker, inline message: String, inline cause: Throwable): Unit = ${LoggerMacro.errorMessageCauseMarker('underlying, 'marker, 'message, 'cause)}
+  inline def error(inline marker: Marker, inline message: String, inline args: Any*): Unit = ${LoggerMacro.errorMessageArgsMarker('underlying, 'marker, 'message, 'args)}
+  inline def whenErrorEnabled(inline body: Unit): Unit = ${LoggerMacro.errorCode('underlying, 'body)}
+
+
+  // Warn
+  inline def warn(inline message: String): Unit = ${LoggerMacro.warnMessage('underlying, 'message)}
+  inline def warn(inline message: String, inline cause: Throwable): Unit = ${LoggerMacro.warnMessageCause('underlying, 'message, 'cause)}
+  inline def warn(inline message: String, inline args: Any*): Unit = ${LoggerMacro.warnMessageArgs('underlying, 'message, 'args)}
+  inline def warn(inline marker: Marker, inline message: String): Unit = ${LoggerMacro.warnMessageMarker('underlying, 'marker, 'message)}
+  inline def warn(inline marker: Marker, inline message: String, inline cause: Throwable): Unit = ${LoggerMacro.warnMessageCauseMarker('underlying, 'marker, 'message, 'cause)}
+  inline def warn(inline marker: Marker, inline message: String, inline args: Any*): Unit = ${LoggerMacro.warnMessageArgsMarker('underlying, 'marker, 'message, 'args)}
+  inline def whenWarnEnabled(inline body: Unit): Unit = ${LoggerMacro.warnCode('underlying, 'body)}
+
+
+  // Info
+  inline def info(inline message: String): Unit = ${LoggerMacro.infoMessage('underlying, 'message)}
+  inline def info(inline message: String, inline cause: Throwable): Unit = ${LoggerMacro.infoMessageCause('underlying, 'message, 'cause)}
+  inline def info(inline message: String, inline args: Any*): Unit = ${LoggerMacro.infoMessageArgs('underlying, 'message, 'args)}
+  inline def info(inline marker: Marker, inline message: String): Unit = ${LoggerMacro.infoMessageMarker('underlying, 'marker, 'message)}
+  inline def info(inline marker: Marker, inline message: String, inline cause: Throwable): Unit = ${LoggerMacro.infoMessageCauseMarker('underlying, 'marker, 'message, 'cause)}
+  inline def info(inline marker: Marker, inline message: String, inline args: Any*): Unit = ${LoggerMacro.infoMessageArgsMarker('underlying, 'marker, 'message, 'args)}
+  inline def whenInfoEnabled(inline body: Unit): Unit = ${LoggerMacro.infoCode('underlying, 'body)}
+
+
+  // Debug
+  inline def debug(inline message: String): Unit = ${LoggerMacro.debugMessage('underlying, 'message)}
+  inline def debug(inline message: String, inline cause: Throwable): Unit = ${LoggerMacro.debugMessageCause('underlying, 'message, 'cause)}
+  inline def debug(inline message: String, inline args: Any*): Unit = ${LoggerMacro.debugMessageArgs('underlying, 'message, 'args)}
+  inline def debug(inline marker: Marker, inline message: String): Unit = ${LoggerMacro.debugMessageMarker('underlying, 'marker, 'message)}
+  inline def debug(inline marker: Marker, inline message: String, inline cause: Throwable): Unit = ${LoggerMacro.debugMessageCauseMarker('underlying, 'marker, 'message, 'cause)}
+  inline def debug(inline marker: Marker, inline message: String, inline args: Any*): Unit = ${LoggerMacro.debugMessageArgsMarker('underlying, 'marker, 'message, 'args)}
+  inline def whenDebugEnabled(inline body: Unit): Unit = ${LoggerMacro.debugCode('underlying, 'body)}
+
+
+  // Trace
+  inline def trace(inline message: String): Unit = ${LoggerMacro.traceMessage('underlying, 'message)}
+  inline def trace(inline message: String, inline cause: Throwable): Unit = ${LoggerMacro.traceMessageCause('underlying, 'message, 'cause)}
+  inline def trace(inline message: String, inline args: Any*): Unit = ${LoggerMacro.traceMessageArgs('underlying, 'message, 'args)}
+  inline def trace(inline marker: Marker, inline message: String): Unit = ${LoggerMacro.traceMessageMarker('underlying, 'marker, 'message)}
+  inline def trace(inline marker: Marker, inline message: String, inline cause: Throwable): Unit = ${LoggerMacro.traceMessageCauseMarker('underlying, 'marker, 'message, 'cause)}
+  inline def trace(inline marker: Marker, inline message: String, inline args: Any*): Unit = ${LoggerMacro.traceMessageArgsMarker('underlying, 'marker, 'message, 'args)}
+  inline def whenTraceEnabled(inline body: Unit): Unit = ${LoggerMacro.traceCode('underlying, 'body)}
+}