refs #10: Added AsArray type class

shared/src/main/scala/io/estatico/newtype/arrays/AsArray.scala

@@ -0,0 +1,45 @@
+package io.estatico.newtype.arrays
+
+import scala.reflect.ClassTag
+
+trait AsArray[N] {
+ type Repr
+ def clsTag: ClassTag[Repr]
+
+ final def empty: Array[N] = Array.empty(clsTag).asInstanceOf[Array[N]]
+
+ final def apply(xs: N*): Array[N] =
+ Array(xs.asInstanceOf[Seq[Repr]]: _*)(clsTag).asInstanceOf[Array[N]]
+
+ final def upcast[R](array: Array[R]): Array[N] = array.asInstanceOf[Array[N]]
+
+ final def downcast(array: Array[N]): Array[Repr] = array.asInstanceOf[Array[Repr]]
+}
+
+object AsArray {
+
+ type Aux[N, R] = AsArray[N] { type Repr = R }
+
+ def unsafeDerive[N, R](implicit ct: ClassTag[R]): Aux[N, R] =
+ new AsArray[N] {
+ type Repr = R
+ override def clsTag: ClassTag[Repr] = ct
+ }
+
+ def empty[N](implicit ev: AsArray[N]): Array[N] = ev.empty
+
+ def apply[N](xs: N*)(implicit ev: AsArray[N]): Array[N] = ev(xs: _*)
+
+ def upcast[R, N](array: Array[R])(implicit ev: Aux[N, R]): Array[N] = ev.upcast(array)
+
+ def upcast[N]: UpcastPartiallyApplied[N] = _upcast.asInstanceOf[UpcastPartiallyApplied[N]]
+
+ def downcast[N](array: Array[N])(implicit ev: AsArray[N]): Array[ev.Repr] = ev.downcast(array)
+
+ final class UpcastPartiallyApplied[N] private[AsArray] {
+ def apply[R](array: Array[R])(implicit ev: Aux[N, R]): Array[N] = upcast[R, N](array)
+ }
+
+ private val _upcast = new UpcastPartiallyApplied[Nothing]
+}
+

shared/src/main/scala/io/estatico/newtype/macros/NewTypeMacros.scala

@@ -1,6 +1,7 @@
 package io.estatico.newtype.macros
 
 import io.estatico.newtype.Coercible
+import io.estatico.newtype.arrays.AsArray
 import scala.reflect.ClassTag
 import scala.reflect.macros.blackbox
 
@@ -39,8 +40,8 @@ private[macros] class NewTypeMacros(val c: blackbox.Context)
 
  val CoercibleCls = typeOf[Coercible[Nothing, Nothing]].typeSymbol
  val CoercibleObj = CoercibleCls.companion
+ val AsArrayObj = q"io.estatico.newtype.arrays.AsArray"
  val ClassTagCls = typeOf[ClassTag[Nothing]].typeSymbol
- val ClassTagObj = ClassTagCls.companion
  val ObjectCls = typeOf[Object].typeSymbol
 
  // We need to know if the newtype is defined in an object so we can report
@@ -123,7 +124,8 @@ private[macros] class NewTypeMacros(val c: blackbox.Context)
  maybeGenerateUnapplyMethod(clsDef, valDef, tparamsNoVar, tparamNames) :::
  maybeGenerateOpsDef(clsDef, valDef, tparamsNoVar, tparamNames) :::
  generateCoercibleInstances(tparamsNoVar, tparamNames, tparamsWild) :::
- generateDerivingMethods(tparamsNoVar, tparamNames, tparamsWild)
+ generateDerivingMethods(tparamsNoVar, tparamNames, tparamsWild) :::
+ List(generateAsArrayInstance(clsDef, valDef, tparamsNoVar, tparamNames))
 
  val newtypeObjParents = objParents :+ tq"$typesTraitName"
  val newtypeObjDef = q"""
@@ -318,6 +320,36 @@ private[macros] class NewTypeMacros(val c: blackbox.Context)
  )
  }
 
+ def generateAsArrayInstance(
+ clsDef: ClassDef, valDef: ValDef, tparamsNoVar: List[TypeDef], tparamNames: List[TypeName]
+ ): Tree = {
+ val Repr = tq"${valDef.tpt}"
+ val Type = if (tparamNames.isEmpty) tq"${clsDef.name}" else tq"${clsDef.name}[..$tparamNames]"
+ //val clsTagType = if (tparamNames.isEmpty) Repr else tq"$Repr forSome { ..$tparamsNoVar }"
+ summonImplicit(tq"$ClassTagCls[$Repr]") match {
+ case Some(Typed(ct, _)) =>
+ if (tparamNames.isEmpty) {
+ q"""implicit def asArray: $AsArrayObj.Aux[$Type, $Repr] =
+ $AsArrayObj.unsafeDerive[$Type, $Repr]($ct)"""
+ } else {
+ q"""implicit def asArray[..$tparamsNoVar]: $AsArrayObj.Aux[$Type, $Repr] =
+ $AsArrayObj.unsafeDerive[$Type, $Repr]($ct)"""
+ }
+ case _ =>
+ if (tparamsNoVar.isEmpty) {
+ q"""implicit def asArray(
+ implicit ct: $ClassTagCls[$Repr]
+ ): $AsArrayObj.Aux[$Type, $Repr] =
+ $AsArrayObj.unsafeDerive[$Type, $Repr]"""
+ } else {
+ q"""implicit def asArray[..$tparamsNoVar](
+ implicit ct: $ClassTagCls[$Repr]
+ ): $AsArrayObj.Aux[$Type, $Repr] =
+ $AsArrayObj.unsafeDerive[$Type, $Repr]"""
+ }
+ }
+ }
+
  def getConstructor(body: List[Tree]): DefDef = body.collectFirst {
  case dd: DefDef if dd.name == termNames.CONSTRUCTOR => dd
  }.getOrElse(fail("Failed to locate constructor"))
@@ -350,4 +382,13 @@ private[macros] class NewTypeMacros(val c: blackbox.Context)
  fail(s"newtypes do not support inheritance; illegal supertypes: ${unsupported.mkString(", ")}")
  }
  }
+
+ /** Return the implicit value, if exists, for the given type `tpt`. */
+ def summonImplicit(tpt: Tree): Option[Tree] = {
+ val typeResult = c.typecheck(tpt, c.TYPEmode, silent = true)
+ if (typeResult.isEmpty) None else {
+ val implicitResult = c.inferImplicitValue(typeResult.tpe)
+ if (implicitResult.isEmpty) None else Some(implicitResult)
+ }
+ }
 }

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

@@ -1,5 +1,6 @@
 package io.estatico.newtype.macros
 
+import io.estatico.newtype.arrays.AsArray
 import org.scalatest.{FlatSpec, Matchers}
 import io.estatico.newtype.ops._
 import org.scalacheck.Arbitrary
@@ -27,7 +28,7 @@ class NewTypeMacrosTest extends FlatSpec with Matchers {
 
  it should "not generate an accessor method if private" in {
  // This is also useful so we can define local newtypes.
- @newtype case class Foo0[A](private val value: A)
+ @newtype(debug=true) case class Foo0[A](private val value: A)
  Foo0('a') shouldBe 'a'
  assertDoesNotCompile("Foo0('a').value")
  }
@@ -39,9 +40,7 @@ class NewTypeMacrosTest extends FlatSpec with Matchers {
 
  it should "work in arrays" in {
  val foo = Foo(313)
- // See https://github.com/estatico/scala-newtype/issues/25
- // Array(foo).head shouldBe foo
- Array[Int](313).asInstanceOf[Array[Foo]].head shouldBe foo
+ AsArray(foo).head shouldBe foo
  }
 
  behavior of "@newtype class"
@@ -101,9 +100,7 @@ class NewTypeMacrosTest extends FlatSpec with Matchers {
  it should "work in arrays" in {
  val repr = Set(Option("newtypes"))
  val ot = OptionT(repr)
- // See https://github.com/estatico/scala-newtype/issues/25
- // Array(ot).head shouldBe ot
- Array(repr).asInstanceOf[Array[OptionT[Set, String]]].head shouldBe ot
+ AsArray(ot).head shouldBe ot
  }
 
  behavior of "@newtype with type bounds"
@@ -365,7 +362,7 @@ class NewTypeMacrosTest extends FlatSpec with Matchers {
 
 object NewTypeMacrosTest {
 
- @newtype case class Foo(value: Int)
+ @newtype(debug=true) case class Foo(value: Int)
 
  @newtype case class Nested(value: Foo)