Scala 3

Author: Russ Remple

.gitignore

@@ -11,4 +11,4 @@ repo/
 *.swp
 .idea*
 .DS_Store
-.bsp/
+.bsp/

build.sbt

@@ -4,7 +4,7 @@ description := "Scala syntax for Guice"
 
 organization := "net.codingwell"
 
-version := "5.1.0"
+version := "5.2.0"
 versionScheme := Some("pvp")
 
 licenses := Seq("Apache 2" -> new URL("http://www.apache.org/licenses/LICENSE-2.0.txt"))
@@ -13,28 +13,37 @@ homepage := Some(url("https://github.com/codingwell/scala-guice"))
 
 libraryDependencies ++= Seq(
   "com.google.inject" % "guice" % "5.1.0",
-  "org.scala-lang" % "scala-reflect" % scalaVersion.value
+  "org.scalatest" %% "scalatest" % "3.2.9" % "test",
+  "com.google.code.findbugs" % "jsr305" % "3.0.2" % "compile"
 )
 
-libraryDependencies += "org.scalatest" %% "scalatest" % "3.2.9" % "test"
-
-libraryDependencies += "com.google.code.findbugs" % "jsr305" % "3.0.2" % "compile"
-
-libraryDependencies += "org.scala-lang.modules" %% "scala-collection-compat" % "2.1.2"
+libraryDependencies ++= {
+  CrossVersion.partialVersion(scalaVersion.value) match {
+    case Some((2, n)) => Seq(
+      "org.scala-lang.modules" %% "scala-collection-compat" % "2.1.2",
+      "org.scala-lang" % "scala-reflect" % scalaVersion.value
+    )
+    case _ => Seq.empty
+  }
+}
 
 autoAPIMappings := true
 
-scalaVersion := "2.13.8"
+//scalaVersion := "2.13.8"
 
-crossScalaVersions := Seq("2.11.12", "2.12.15", "2.13.8")
+val scala3 = "3.2.2"
+scalaVersion := scala3 // for IDE
+//crossScalaVersions := Seq(scala3)
+crossScalaVersions := Seq("2.11.12", "2.12.15", "2.13.8", scala3)
 
 scalacOptions := Seq("-unchecked", "-deprecation", "-feature")
 
-Compile / unmanagedSourceDirectories += {
+Compile / unmanagedSourceDirectories ++= {
   val sourceDir = (Compile / sourceDirectory).value
   CrossVersion.partialVersion(scalaVersion.value) match {
-    case Some((2, n)) if n >= 13 => sourceDir / "scala-2.13+"
-    case _ => sourceDir / "scala-2.12-"
+    case Some((2, n)) if n >= 13 => Seq(sourceDir / "scala-2.13+")
+    case Some((3, _)) => Seq(sourceDir / "scala-2.13+")
+    case _ => Seq(sourceDir / "scala-2.12-")
   }
 }
 

src/main/scala-3/net/codingwell/scalaguice/BindingExtensions.scala

@@ -0,0 +1,74 @@
+/*
+ *  Copyright 2010-2014 Benjamin Lings
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package net.codingwell.scalaguice
+
+import com.google.inject.Binder
+import com.google.inject.binder._
+import com.google.inject.name.Names
+import java.lang.annotation.{Annotation => JAnnotation}
+import javax.inject.Provider
+import scala.reflect.ClassTag
+
+/**
+ * Extensions for Guice's binding DSL.
+ * These allow using a type parameter instead of `classOf[Foo]`
+ * or `new TypeLiteral[Bar[Foo]] {}`. The extra methods are
+ * named as those in the normal binding DSL suffixed with `Type`.
+ *
+ * For example, instead of
+ * {{{
+ * binder.bind(new TypeLiteral[Bar[Foo]]{}).to(classOf[FooBarImpl])
+ * }}}
+ * use
+ * {{{
+ * import BindingExtensions._
+ * binder.bindType[Bar[Foo]].toType[FooImpl]
+ * }}}
+ *
+ * '''Note''' This syntax allows binding to and from generic types.
+ * It doesn't currently allow bindings between wildcard types because the
+ * manifests for wildcard types don't provide access to type bounds.
+ */
+object BindingExtensions {
+
+  implicit class ScalaBinder(val self: Binder) extends AnyVal {
+    inline def bindType[T]: AnnotatedBindingBuilder[T] = self.bind(typeLiteral[T])
+  }
+
+  implicit class ScalaScopedBindingBuilder(val self: ScopedBindingBuilder) extends AnyVal {
+    def inType[TAnn <: JAnnotation : ClassTag](): Unit = self.in(cls[TAnn])
+  }
+
+  implicit class ScalaLinkedBindingBuilder[T](val self: LinkedBindingBuilder[T]) extends AnyVal {
+    inline def toType[TImpl <: T]: ScopedBindingBuilder = self.to(typeLiteral[TImpl])
+
+    def toProviderType[TProvider <: Provider[_ <: T] : ClassTag]: ScopedBindingBuilder = self.toProvider(cls[TProvider])
+  }
+
+  implicit class ScalaAnnotatedBindingBuilder[T](val self: AnnotatedBindingBuilder[T]) extends AnyVal {
+    def annotatedWithType[TAnn <: JAnnotation : ClassTag]: LinkedBindingBuilder[T] = self.annotatedWith(cls[TAnn])
+  }
+
+  implicit class ScalaAnnotatedConstantBindingBuilder(val self: AnnotatedConstantBindingBuilder) extends AnyVal {
+    def annotatedWithType[TAnn <: JAnnotation : ClassTag]: ConstantBindingBuilder = self.annotatedWith(cls[TAnn])
+    def annotatedWithName(name: String): ConstantBindingBuilder = self.annotatedWith(Names.named(name))
+  }
+
+  implicit class ScalaConstantBindingBuilder(val self: ConstantBindingBuilder) extends AnyVal {
+    def to[T: ClassTag](): Unit = self.to(cls[T])
+  }
+}
+

src/main/scala-3/net/codingwell/scalaguice/InjectorExtensions.scala

@@ -0,0 +1,39 @@
+/*
+ *  Copyright 2010-2014 Benjamin Lings
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package net.codingwell.scalaguice
+
+import com.google.inject.{Binding, Injector, Key, Provider}
+import java.lang.annotation.Annotation
+import net.codingwell.scalaguice.KeyExtensions._
+import scala.reflect.ClassTag
+
+object InjectorExtensions {
+
+  implicit class ScalaInjector(val self: Injector) /*extends AnyVal*/ {
+    inline def instance[T]: T = self.getInstance(typeLiteral[T].toKey)
+    inline def instance[T](ann: Annotation): T = self.getInstance(typeLiteral[T].annotatedWith(ann))
+    inline def instance[T, Ann <: Annotation : ClassTag]: T = self.getInstance(typeLiteral[T].annotatedWith[Ann])
+
+    inline def existingBinding[T]: Option[Binding[T]] = existingBinding(typeLiteral[T].toKey)
+    inline def existingBinding[T](ann: Annotation): Option[Binding[T]] = existingBinding(typeLiteral[T].annotatedWith(ann))
+    inline def existingBinding[T, Ann <: Annotation : ClassTag]: Option[Binding[T]] = existingBinding(typeLiteral[T].annotatedWith[Ann])
+    def existingBinding[T](key: Key[T]): Option[Binding[T]] = Option(self.getExistingBinding(key))
+
+    inline def provider[T]: Provider[T] = self.getProvider(typeLiteral[T].toKey)
+    inline def provider[T](ann: Annotation): Provider[T] = self.getProvider(typeLiteral[T].annotatedWith(ann))
+    inline def provider[T, Ann <: Annotation : ClassTag]: Provider[T] = self.getProvider(typeLiteral[T].annotatedWith[Ann])
+  }
+}