Add support for scala-native and scalajs 1.0

Author: marcesquerra

.gitignore

@@ -1,2 +1,3 @@
 .idea/
 target/
+*.hnir

build.sbt

@@ -4,15 +4,22 @@ import sbtcrossproject.CrossPlugin.autoImport.crossProject
 organization in ThisBuild := "io.estatico"
 
 lazy val root = project.in(file("."))
-  .aggregate(newtypeJS, newtypeJVM, catsTestsJVM)
+  .aggregate(newtypeJS, newtypeJVM, newtypeNative, catsTestsJVM)
   .settings(noPublishSettings)
 
-lazy val newtype = crossProject(JSPlatform, JVMPlatform).in(file("."))
+lazy val newtype = crossProject(JSPlatform, JVMPlatform, NativePlatform).in(file("."))
   .settings(defaultSettings)
   .settings(releasePublishSettings)
   .settings(name := "newtype")
+  .nativeSettings(
+    crossScalaVersions := List("2.11.12"),
+    scalaVersion := "2.11.12",
+    nativeLinkStubs := true,
+    Compile / scalacOptions += "-Yno-predef" // needed to ensure users can use -Yno-predef
+  )
 
 lazy val newtypeJVM = newtype.jvm
+lazy val newtypeNative = newtype.native
 lazy val newtypeJS = newtype.js
 
 lazy val catsTests = crossProject(JVMPlatform).in(file("cats-tests"))
@@ -116,7 +123,6 @@ lazy val defaultSettings = Seq(
 
 lazy val defaultScalacOptions = scalacOptions ++= Seq(
   "-Xfatal-warnings",
-  "-Yno-predef", // needed to ensure users can use -Yno-predef
   "-unchecked",
   "-feature",
   "-deprecation",
@@ -129,12 +135,17 @@ lazy val defaultScalacOptions = scalacOptions ++= Seq(
   case _ =>
     // on scala 2.12+ some spurious unused warnings get triggered
     Seq("-Xlint:-unused,_")
-})
+}) ++ (if (crossProjectPlatform.value == NativePlatform)
+    Seq() // Removing the 'predef' on scala native-tests, breaks the test integration with sbt
+  else
+    Seq("-Yno-predef")) // needed to ensure users can use -Yno-predef
 
 lazy val defaultLibraryDependencies = libraryDependencies ++= Seq(
   scalaOrganization.value % "scala-reflect" % scalaVersion.value % Provided,
   scalaOrganization.value % "scala-compiler" % scalaVersion.value % Provided,
   "org.scalacheck" %%% "scalacheck" % "1.14.3" % Test,
-  "org.scalatest" %%% "scalatest" % "3.1.1" % Test,
-  "org.scalatestplus" %%% "scalacheck-1-14" % "3.1.1.1" % Test,
+  "org.scalatest" %%% "scalatest" % "3.2.0-M4" % Test,
+  "org.scalatestplus" %%% "scalacheck-1-14" % "3.2.0.0-M4" % Test
 )
+
+

js/src/test/scala/io/estatico/newtype/macros/NonNativeNewTypeMacrosTest.scala

@@ -0,0 +1,25 @@
+package io.estatico.newtype.macros
+
+import org.scalatest.flatspec.AnyFlatSpec
+import org.scalatest.matchers.should.Matchers
+import io.estatico.newtype.ops._
+import org.scalacheck.Arbitrary
+
+class NonNativeNewTypeMacrosTest extends AnyFlatSpec with Matchers {
+
+  import NewTypeMacrosTest._
+
+  behavior of "@newtype with type bounds"
+
+  it should "enforce type bounds" in {
+    val x = Sub(new java.util.HashMap[String, Int]): Sub[java.util.HashMap[String, Int]]
+    val y = Sub(new java.util.concurrent.ConcurrentHashMap[String, Int])
+
+    assertCompiles("x: Sub[java.util.HashMap[String, Int]]")
+    assertCompiles("y: Sub[java.util.concurrent.ConcurrentHashMap[String, Int]]")
+
+    assertDoesNotCompile("x: Sub[java.util.concurrent.ConcurrentHashMap[String, Int]]")
+    assertDoesNotCompile("y: Sub[java.util.HashMap[String, Int]]")
+  }
+
+}

jvm/src/test/scala/io/estatico/newtype/macros/NonNativeNewTypeMacrosTest.scala

@@ -0,0 +1,25 @@
+package io.estatico.newtype.macros
+
+import org.scalatest.flatspec.AnyFlatSpec
+import org.scalatest.matchers.should.Matchers
+import io.estatico.newtype.ops._
+import org.scalacheck.Arbitrary
+
+class NonNativeNewTypeMacrosTest extends AnyFlatSpec with Matchers {
+
+  import NewTypeMacrosTest._
+
+  behavior of "@newtype with type bounds"
+
+  it should "enforce type bounds" in {
+    val x = Sub(new java.util.HashMap[String, Int]): Sub[java.util.HashMap[String, Int]]
+    val y = Sub(new java.util.concurrent.ConcurrentHashMap[String, Int])
+
+    assertCompiles("x: Sub[java.util.HashMap[String, Int]]")
+    assertCompiles("y: Sub[java.util.concurrent.ConcurrentHashMap[String, Int]]")
+
+    assertDoesNotCompile("x: Sub[java.util.concurrent.ConcurrentHashMap[String, Int]]")
+    assertDoesNotCompile("y: Sub[java.util.HashMap[String, Int]]")
+  }
+
+}

project/plugins.sbt

@@ -2,5 +2,8 @@ addSbtPlugin("com.jsuereth" % "sbt-pgp" % "1.1.1")
 addSbtPlugin("com.github.gseitz" % "sbt-release" % "1.0.13")
 addSbtPlugin("com.dwijnand" % "sbt-travisci" % "1.2.0")
 addSbtPlugin("org.xerial.sbt" % "sbt-sonatype" % "3.8.1")
-addSbtPlugin("org.scala-js" % "sbt-scalajs" % "1.0.1")
-addSbtPlugin("org.portable-scala" % "sbt-scalajs-crossproject" % "1.0.0")
+
+addSbtPlugin("org.portable-scala" % "sbt-scalajs-crossproject"      % "1.0.0")
+addSbtPlugin("org.portable-scala" % "sbt-scala-native-crossproject" % "1.0.0")
+addSbtPlugin("org.scala-js"       % "sbt-scalajs"                   % "1.0.1")
+addSbtPlugin("org.scala-native"   % "sbt-scala-native"              % "0.4.0-M2")

shared/src/test/scala/io/estatico/newtype/macros/NewTypeMacrosTest.scala

@@ -93,7 +93,8 @@ class NewTypeMacrosTest extends AnyFlatSpec with Matchers {
     val y = Cov(List(None))
     assertCompiles("y: Cov[None.type]")
 
-    def someOrZero[A](c: Cov[Option[Int]]): Cov[Int] = Cov(c.value.map(_.getOrElse(0)))
+    def someOrZero[A](c: Cov[Option[Int]]): Cov[Int] =
+      Cov(c.value.map(_.getOrElse(0)))
 
     someOrZero(x) shouldBe List(1)
     someOrZero(y) shouldBe List(0)
@@ -111,13 +112,12 @@ class NewTypeMacrosTest extends AnyFlatSpec with Matchers {
   behavior of "@newtype with type bounds"
 
   it should "enforce type bounds" in {
-    val x = Sub(new java.util.HashMap[String, Int]): Sub[java.util.HashMap[String, Int]]
-    val y = Sub(new java.util.concurrent.ConcurrentHashMap[String, Int])
+    val x = Sub(new java.util.HashMap[String, Int]): Sub[
+      java.util.HashMap[String, Int]
+    ]
 
     assertCompiles("x: Sub[java.util.HashMap[String, Int]]")
-    assertCompiles("y: Sub[java.util.concurrent.ConcurrentHashMap[String, Int]]")
 
-    assertDoesNotCompile("x: Sub[java.util.concurrent.ConcurrentHashMap[String, Int]]")
     assertDoesNotCompile("y: Sub[java.util.HashMap[String, Int]]")
   }
 
@@ -137,7 +137,8 @@ class NewTypeMacrosTest extends AnyFlatSpec with Matchers {
   it should "support deriving type class instances for simple newtypes via coerce" in {
     @newtype case class Text(private val s: String)
     object Text {
-      implicit val arb: Arbitrary[Text] = scala.Predef.implicitly[Arbitrary[String]].coerce
+      implicit val arb: Arbitrary[Text] =
+        scala.Predef.implicitly[Arbitrary[String]].coerce
     }
     val x = scala.Predef.implicitly[Arbitrary[Text]].arbitrary.sample.get
     assertCompiles("x: Text")
@@ -148,7 +149,8 @@ class NewTypeMacrosTest extends AnyFlatSpec with Matchers {
   it should "support deriving type class instances for higher-kinded newtypes" in {
     @newtype class Nel[A](private val list: List[A])
     object Nel {
-      def apply[A](head: A, tail: List[A]): Nel[A] = (head +: tail).coerce[Nel[A]]
+      def apply[A](head: A, tail: List[A]): Nel[A] =
+        (head +: tail).coerce[Nel[A]]
       implicit val functor: Functor[Nel] = derivingK
     }
 
@@ -160,8 +162,10 @@ class NewTypeMacrosTest extends AnyFlatSpec with Matchers {
   it should "support deriving type class instances for higher-kinded newtypes via coerce" in {
     @newtype class Nel[A](private val list: List[A])
     object Nel {
-      def apply[A](head: A, tail: List[A]): Nel[A] = (head +: tail).coerce[Nel[A]]
-      implicit val functor: Functor[Nel] = scala.Predef.implicitly[Functor[List]].coerce
+      def apply[A](head: A, tail: List[A]): Nel[A] =
+        (head +: tail).coerce[Nel[A]]
+      implicit val functor: Functor[Nel] =
+        scala.Predef.implicitly[Functor[List]].coerce
     }
 
     val x = scala.Predef.implicitly[Functor[Nel]].map(Nel(1, List(2, 3)))(_ * 2)
@@ -196,12 +200,16 @@ class NewTypeMacrosTest extends AnyFlatSpec with Matchers {
     object EitherT {
       // Derive the Arbitrary instance explicitly
       implicit def arb[F[_], L, R](
-        implicit a: Arbitrary[F[Either[L, R]]]
+          implicit a: Arbitrary[F[Either[L, R]]]
       ): Arbitrary[EitherT[F, L, R]] = deriving
     }
     val x = {
       import scala.Predef._
-      scala.Predef.implicitly[Arbitrary[EitherT[List, String, Int]]].arbitrary.sample.get
+      scala.Predef
+        .implicitly[Arbitrary[EitherT[List, String, Int]]]
+        .arbitrary
+        .sample
+        .get
     }
     assertCompiles("x: EitherT[List, String, Int]")
     val y = x.coerce[List[Either[String, Int]]]
@@ -213,12 +221,16 @@ class NewTypeMacrosTest extends AnyFlatSpec with Matchers {
     object EitherT {
       // Derive the Arbitrary instance explicitly
       implicit def arb[F[_], L, R](
-        implicit a: Arbitrary[F[Either[L, R]]]
+          implicit a: Arbitrary[F[Either[L, R]]]
       ): Arbitrary[EitherT[F, L, R]] = a.coerce
     }
     val x = {
       import scala.Predef._
-      scala.Predef.implicitly[Arbitrary[EitherT[List, String, Int]]].arbitrary.sample.get
+      scala.Predef
+        .implicitly[Arbitrary[EitherT[List, String, Int]]]
+        .arbitrary
+        .sample
+        .get
     }
     assertCompiles("x: EitherT[List, String, Int]")
     val y = x.coerce[List[Either[String, Int]]]
@@ -230,12 +242,16 @@ class NewTypeMacrosTest extends AnyFlatSpec with Matchers {
     object EitherT {
       // Auto-derive all type classes of kind * -> *
       implicit def typeclass[T[_], F[_], L, R](
-        implicit t: T[F[Either[L, R]]]
+          implicit t: T[F[Either[L, R]]]
       ): T[EitherT[F, L, R]] = deriving
     }
     val x = {
       import scala.Predef._
-      scala.Predef.implicitly[Arbitrary[EitherT[List, String, Int]]].arbitrary.sample.get
+      scala.Predef
+        .implicitly[Arbitrary[EitherT[List, String, Int]]]
+        .arbitrary
+        .sample
+        .get
     }
     assertCompiles("x: EitherT[List, String, Int]")
     val y = x.coerce[List[Either[String, Int]]]
@@ -247,12 +263,16 @@ class NewTypeMacrosTest extends AnyFlatSpec with Matchers {
     object EitherT {
       // Auto-derive all type classes of kind * -> *
       implicit def typeclass[T[_], F[_], L, R](
-        implicit t: T[F[Either[L, R]]]
+          implicit t: T[F[Either[L, R]]]
       ): T[EitherT[F, L, R]] = t.coerce
     }
     val x = {
       import scala.Predef._
-      scala.Predef.implicitly[Arbitrary[EitherT[List, String, Int]]].arbitrary.sample.get
+      scala.Predef
+        .implicitly[Arbitrary[EitherT[List, String, Int]]]
+        .arbitrary
+        .sample
+        .get
     }
     assertCompiles("x: EitherT[List, String, Int]")
     val y = x.coerce[List[Either[String, Int]]]
@@ -335,8 +355,8 @@ class NewTypeMacrosTest extends AnyFlatSpec with Matchers {
   }
 
   "unapply = true" should "generate an unapply method" in {
-    @newtype   (unapply = true) case class X0(private val x: String)
-    @newtype   (unapply = true) case class X1[A](private val x: A)
+    @newtype(unapply = true) case class X0(private val x: String)
+    @newtype(unapply = true) case class X1[A](private val x: A)
     @newsubtype(unapply = true) case class Y0(private val x: String)
     @newsubtype(unapply = true) case class Y1[A](private val x: A)
 
@@ -406,21 +426,29 @@ object NewTypeMacrosTest {
   @newtype case class Maybe[A](unsafeGet: A) {
     def isEmpty: Boolean = unsafeGet == null
     def isDefined: Boolean = unsafeGet != null
-    def map[B](f: A => B): Maybe[B] = if (isEmpty) Maybe.empty else Maybe(f(unsafeGet))
-    def flatMap[B](f: A => Maybe[B]): Maybe[B] = if (isEmpty) Maybe.empty else f(unsafeGet)
-    def filter(p: A => Boolean): Maybe[A] = if (isEmpty || !p(unsafeGet)) Maybe.empty else this
-    def filterNot(p: A => Boolean): Maybe[A] = if (isEmpty || p(unsafeGet)) Maybe.empty else this
+    def map[B](f: A => B): Maybe[B] =
+      if (isEmpty) Maybe.empty else Maybe(f(unsafeGet))
+    def flatMap[B](f: A => Maybe[B]): Maybe[B] =
+      if (isEmpty) Maybe.empty else f(unsafeGet)
+    def filter(p: A => Boolean): Maybe[A] =
+      if (isEmpty || !p(unsafeGet)) Maybe.empty else this
+    def filterNot(p: A => Boolean): Maybe[A] =
+      if (isEmpty || p(unsafeGet)) Maybe.empty else this
     def orElse(ma: => Maybe[A]): Maybe[A] = if (isDefined) this else ma
     def getOrElse(a: => A): A = if (isDefined) unsafeGet else a
-    def getOrThrow: A = if (isDefined) unsafeGet else throw new NoSuchElementException("Maybe.empty.get")
-    def cata[B](ifEmpty: => B, ifDefined: A => B): B = if (isEmpty) ifEmpty else ifDefined(unsafeGet)
+    def getOrThrow: A =
+      if (isDefined) unsafeGet
+      else throw new NoSuchElementException("Maybe.empty.get")
+    def cata[B](ifEmpty: => B, ifDefined: A => B): B =
+      if (isEmpty) ifEmpty else ifDefined(unsafeGet)
     def fold[B](ifEmpty: => B)(ifDefined: A => B): B = cata(ifEmpty, ifDefined)
     def contains(a: A): Boolean = isDefined && unsafeGet == a
     def exists(p: A => Boolean): Boolean = isDefined && p(unsafeGet)
   }
   object Maybe {
     def empty[A]: Maybe[A] = null.asInstanceOf[Maybe[A]]
-    def fromOption[A](x: Option[A]): Maybe[A] = (if (x.isDefined) x.get else null).asInstanceOf[Maybe[A]]
+    def fromOption[A](x: Option[A]): Maybe[A] =
+      (if (x.isDefined) x.get else null).asInstanceOf[Maybe[A]]
   }
 
   @newtype case class Id[A](value: A) {