4.2.8 Fix primative arrays and unit being void

CHANGELOG.md

@@ -1,3 +1,21 @@
+4.2.8
+-----
+2020-06-22
+
+* Fix primative arrays
+
+4.2.7
+-----
+2020-05-27
+
+* Guice 4.2.3
+
+4.2.6
+-----
+2020-07-19
+
+* Fix for Singleton types
+
 4.2.5
 -----
 2019-06-22

README.md

@@ -14,18 +14,18 @@ We currently support Scala `2.11, 2.12, 2.13`
 <dependency>
     <groupId>net.codingwell</groupId>
     <artifactId>scala-guice_2.13</artifactId>
-    <version>4.2.7</version>
+    <version>4.2.8</version>
 </dependency>
 ```
 
 ##### sbt:
 ```scala
-"net.codingwell" %% "scala-guice" % "4.2.7"
+"net.codingwell" %% "scala-guice" % "4.2.8"
 ```
 
 ##### gradle:
 ```groovy
-'net.codingwell:scala-guice_2.13:4.2.7'
+'net.codingwell:scala-guice_2.13:4.2.8'
 ```
 
 ### Mixin

build.sbt

@@ -4,7 +4,7 @@ description := "Scala syntax for Guice"
 
 organization := "net.codingwell"
 
-version := "4.2.7"
+version := "4.2.8"
 
 licenses := Seq("Apache 2" -> new URL("http://www.apache.org/licenses/LICENSE-2.0.txt"))
 

src/main/scala/net/codingwell/scalaguice/TypeConversions.scala

@@ -55,18 +55,22 @@ private [scalaguice] object TypeConversions {
 
   }
 
-  def scalaTypeToJavaType(scalaType: ScalaType, mirror: Mirror): JavaType = {
+  def scalaTypeToJavaType(scalaType: ScalaType, mirror: Mirror, allowPrimative: Boolean = false): JavaType = {
     scalaType.dealias match {
       case `anyType` => classOf[java.lang.Object]
       case ExistentialType(symbols, underlying) => scalaTypeToJavaType(underlying, mirror)
-      case ArrayType(argType) => arrayOf(scalaTypeToJavaType(argType, mirror))
+      case ArrayType(argType) => arrayOf(scalaTypeToJavaType(argType, mirror, allowPrimative=true))
       case ClassType(symbol, args) => {
         val rawType = mirror.runtimeClass(symbol)
         val ownerType = findOwnerOf(symbol, mirror)
-        args.map(arg => scalaTypeToJavaType(arg, mirror)) match {
-          case Nil => toWrapper(rawType)
-          case mappedArgs if ownerType.nonEmpty => newParameterizedTypeWithOwner(ownerType.get, rawType, mappedArgs:_*)
-          case mappedArgs => newParameterizedType(rawType, mappedArgs:_*)
+        if(symbol == symbolOf[Unit]) {
+          classOf[scala.runtime.BoxedUnit]
+        } else {
+          args.map(arg => scalaTypeToJavaType(arg, mirror)) match {
+            case Nil => if(allowPrimative) rawType else toWrapper(rawType)
+            case mappedArgs if ownerType.nonEmpty => newParameterizedTypeWithOwner(ownerType.get, rawType, mappedArgs:_*)
+            case mappedArgs => newParameterizedType(rawType, mappedArgs:_*)
+          }
         }
       }
       case WildcardType(lowerBounds, upperBounds) => {

src/test/scala/net/codingwell/scalaguice/ScalaModuleSpec.scala

@@ -145,6 +145,7 @@ class ScalaModuleSpec extends WordSpec with Matchers {
 
     //This test needs work to resolve #65
     "allow binding by name to Unit" ignore {
+      try { 
       val foo:(=> Unit) => String = (a) => "dog"
       val module = new AbstractModule with ScalaModule {
         override def configure() = {
@@ -156,6 +157,9 @@ class ScalaModuleSpec extends WordSpec with Matchers {
       val injector = Guice.createInjector(module)
       val func = injector.instance[(=> Unit) => String]
       func shouldEqual foo
+      } catch {
+        case e: Throwable => { e.printStackTrace; throw e }
+      }
     }
 
 

src/test/scala/net/codingwell/scalaguice/TypeLiteralSpec.scala

@@ -85,7 +85,15 @@ class TypeLiteralSpec extends FunSpec with Matchers {
     }
 
     it("should handle type parameters that are arrays") {
-      typeLiteral[Array[Int]] shouldEqual new TypeLiteral[Array[java.lang.Integer]] {}
+      typeLiteral[Array[Int]] shouldEqual new TypeLiteral[Array[Int]] {}
+    }
+
+    it("should handle type parameters that are boxed primative arrays") {
+      typeLiteral[Array[java.lang.Integer]] shouldEqual new TypeLiteral[Array[java.lang.Integer]] {}
+    }
+
+    it("should handle Primative Arrays") {
+      typeLiteral[Option[Array[Byte]]] shouldEqual new TypeLiteral[Option[Array[Byte]]] {}
     }
 
     it("should create a type literal from a trait") {
@@ -103,6 +111,17 @@ class TypeLiteralSpec extends FunSpec with Matchers {
     it("should handle embedded wildcards with constraints") {
       typeLiteral[Option[_ <: Throwable]] shouldEqual new TypeLiteral[Option[_ <: Throwable]] {}
     }
-
+
+    it("should handle Unit") {
+      typeLiteral[Unit] shouldEqual new TypeLiteral[Unit] {}
+    }
+
+    it("Should handle unit as a generic") {
+      typeLiteral[Function0[Unit]] shouldEqual new TypeLiteral[Function0[Unit]] {}
+    }
+
+    it("Should handle explicit function"){
+      typeLiteral[Function1[Function0[Unit],String]] shouldEqual new TypeLiteral[(=> Unit) => String] {}
+    }
   }
 }