Copied the definitions of MappedTo, MappedToBase, Isomorphism and isomorphicType() which had been removed in Slick 3.5.0.

Author: odisseus

unicorn-core/src/main/scala/org/virtuslab/unicorn/Identifiers.scala

@@ -1,7 +1,5 @@
 package org.virtuslab.unicorn
 
-import slick.lifted.MappedTo
-
 /**
  * Base trait for implementing ids.
  * It is existential trait so it can have only defs.

unicorn-core/src/main/scala/org/virtuslab/unicorn/IsomorphicColumnTypeConversion.scala

@@ -0,0 +1,11 @@
+package org.virtuslab.unicorn
+
+import slick.jdbc.JdbcProfile
+
+import scala.reflect.ClassTag
+
+class IsomorphicColumnTypeConversion(implicit val rtc: JdbcProfile) {
+  import rtc._
+  implicit def isomorphicType[A, B](implicit iso: Isomorphism[A, B], ct: ClassTag[A], jt: BaseColumnType[B]): BaseColumnType[A] =
+    MappedColumnType.base[A, B](iso.map, iso.comap)
+}

unicorn-core/src/main/scala/org/virtuslab/unicorn/MappedTo.scala

@@ -0,0 +1,54 @@
+package org.virtuslab.unicorn
+
+import scala.language.experimental.macros
+import scala.reflect.macros.blackbox.Context
+import scala.util.control.NonFatal
+
+/** An isomorphism between two types that can be used for mapped column types. */
+class Isomorphism[A, B](val map: A => B, val comap: B => A)
+
+trait MappedToBase extends Any {
+  type Underlying
+  def value: Underlying
+}
+
+object MappedToBase {
+  implicit def mappedToIsomorphism[E <: MappedToBase]: Isomorphism[E, E#Underlying] = macro mappedToIsomorphismMacroImpl[E]
+
+  def mappedToIsomorphismMacroImpl[E <: MappedToBase](c: Context)(implicit e: c.WeakTypeTag[E]): c.Expr[Isomorphism[E, E#Underlying]] = {
+    import c.universe._
+    // Check that E <: MappedToBase. Due to SI-8351 the macro can be expanded before scalac has
+    // checked this. The error message here will never be seen because scalac's subsequent bounds
+    // check fails, overriding our error (or backtracking in implicit search).
+    if (!(e.tpe <:< c.typeOf[MappedToBase]))
+      c.abort(c.enclosingPosition, "Work-around for SI-8351 leading to illegal macro-invocation -- You should not see this message")
+    implicit val eutag = c.TypeTag[E#Underlying](e.tpe.member(TypeName("Underlying")).typeSignatureIn(e.tpe))
+    val cons = c.Expr[E#Underlying => E](Function(
+      List(ValDef(Modifiers(Flag.PARAM), TermName("v"), /*Ident(eu.tpe.typeSymbol)*/ TypeTree(), EmptyTree)),
+      Apply(
+        Select(New(TypeTree(e.tpe)), termNames.CONSTRUCTOR),
+        List(Ident(TermName("v"))))))
+    val res = reify { new Isomorphism[E, E#Underlying](_.value, cons.splice) }
+    try c.typecheck(res.tree) catch {
+      case NonFatal(ex) =>
+        val p = c.enclosingPosition
+        val msg = "Error typechecking MappedTo expansion: " + ex.getMessage
+        println(p.source.path + ":" + p.line + ": " + msg)
+        c.error(c.enclosingPosition, msg)
+    }
+    res
+  }
+}
+
+/**
+ * The base type for automatically mapped column types.
+ * Extending this type (with a type parameter ``T`` which is already a
+ * supported column type) lets you use your custom type as a column
+ * type in the Lifted Embedding. You must provide a constructor that
+ * takes a single value of the underlying type (same restriction as
+ * for value classes).
+ */
+trait MappedTo[T] extends Any with MappedToBase {
+  type Underlying = T
+  def value: T
+}