Remove unused values (#847)

codegen/src/main/scala/akka/grpc/gen/javadsl/JavaCodeGenerator.scala

@@ -13,14 +13,20 @@ import templates.JavaCommon.txt.ApiInterface
 import scala.collection.JavaConverters._
 import scala.collection.immutable
 
+import com.github.ghik.silencer.silent
+
 abstract class JavaCodeGenerator extends CodeGenerator {
 
   /** Override this to add generated files per service */
   def perServiceContent: Set[(Logger, Service) => immutable.Seq[CodeGeneratorResponse.File]] = Set.empty
 
   /** Override these to add service-independent generated files */
-  def staticContent(logger: Logger): Set[CodeGeneratorResponse.File] = Set.empty
-  def staticContent(logger: Logger, allServices: Seq[Service]): Set[CodeGeneratorResponse.File] = Set.empty
+  def staticContent(@silent("never used") logger: Logger): Set[CodeGeneratorResponse.File] =
+    Set.empty
+  def staticContent(
+      @silent("never used") logger: Logger,
+      @silent("never used") allServices: Seq[Service]): Set[CodeGeneratorResponse.File] =
+    Set.empty
 
   override def run(request: CodeGeneratorRequest, logger: Logger): CodeGeneratorResponse = {
     val b = CodeGeneratorResponse.newBuilder

codegen/src/main/scala/akka/grpc/gen/scaladsl/Method.scala

@@ -70,18 +70,4 @@ object Method {
     import ops._
     messageType.scalaType.fullName
   }
-
-  private def outerClass(t: Descriptor) =
-    if (t.getFile.toProto.getOptions.getJavaMultipleFiles) ""
-    else {
-      val outerClassName = t.getFile.toProto.getOptions.getJavaOuterClassname
-      if (outerClassName == "") {
-        protoName(t).head.toUpper + protoName(t).tail + "."
-      } else {
-        outerClassName + "."
-      }
-    }
-
-  private def protoName(t: Descriptor) =
-    t.getFile.getName.replaceAll("\\.proto", "").split("/").last
 }

codegen/src/main/scala/akka/grpc/gen/scaladsl/ScalaCodeGenerator.scala

@@ -12,13 +12,17 @@ import com.google.protobuf.compiler.PluginProtos.{ CodeGeneratorRequest, CodeGen
 import scalapb.compiler.GeneratorParams
 import protocbridge.Artifact
 
+import com.github.ghik.silencer.silent
+
 abstract class ScalaCodeGenerator extends CodeGenerator {
   // Override this to add generated files per service
   def perServiceContent: Set[(Logger, Service) => immutable.Seq[CodeGeneratorResponse.File]] = Set.empty
 
   // Override these to add service-independent generated files
-  def staticContent(logger: Logger): Set[CodeGeneratorResponse.File] = Set.empty
-  def staticContent(logger: Logger, allServices: Seq[Service]): Set[CodeGeneratorResponse.File] = Set.empty
+  def staticContent(@silent("never used") logger: Logger): Set[CodeGeneratorResponse.File] = Set.empty
+  def staticContent(
+      @silent("never used") logger: Logger,
+      @silent("never used") allServices: Seq[Service]): Set[CodeGeneratorResponse.File] = Set.empty
 
   override def suggestedDependencies =
     (scalaBinaryVersion: CodeGenerator.ScalaBinaryVersion) =>

codegen/src/main/scala/akka/grpc/gen/scaladsl/ScalaMarshallersCodeGenerator.scala

@@ -10,6 +10,8 @@ import com.google.protobuf.compiler.PluginProtos.CodeGeneratorResponse
 import protocbridge.Artifact
 import templates.ScalaCommon.txt._
 
+import com.github.ghik.silencer.silent
+
 /**
  * Has to be a separate generator rather than a parameter to the existing ones, because
  * it introduces a suggestedDependency on akka-http.
@@ -24,7 +26,9 @@ trait ScalaMarshallersCodeGenerator extends ScalaCodeGenerator {
       Artifact("com.typesafe.akka", s"akka-http_${scalaBinaryVersion.prefix}", BuildInfo.akkaHttpVersion) +: super
         .suggestedDependencies(scalaBinaryVersion)
 
-  def generateMarshalling(logger: Logger, service: Service): immutable.Seq[CodeGeneratorResponse.File] = {
+  def generateMarshalling(
+      @silent("never used") logger: Logger,
+      service: Service): immutable.Seq[CodeGeneratorResponse.File] = {
     val b = CodeGeneratorResponse.File.newBuilder()
     b.setContent(Marshallers(service).body)
     b.setName(s"${service.packageDir}/${service.name}Marshallers.scala")

codegen/src/main/twirl/templates/JavaServer/Handler.scala.txt

@@ -124,7 +124,7 @@ import static @{service.packageName}.@{service.name}.Serializers.*;
           case "@method.grpcName":
             response = @{method.unmarshal}(request.entity().getDataBytes(), @method.deserializer.name, mat, reader)
               .@{if(method.outputStreaming) { "thenApply" } else { "thenCompose" }}(e -> implementation.@{method.name}(e@{if(powerApis) { ", metadata" } else { "" }}))
-              .thenApply(e -> @{method.marshal}(e, @method.serializer.name, mat, writer, system, eHandler));
+              .thenApply(e -> @{method.marshal}(e, @method.serializer.name, writer, system, eHandler));
             break;
           }
           default:

codegen/src/main/twirl/templates/ScalaCommon/Marshallers.scala.txt

@@ -11,11 +11,9 @@ import scala.concurrent.ExecutionContext
 
 import akka.actor.ActorSystem
 import akka.stream.Materializer
-import akka.grpc.Codec
 import akka.grpc.GrpcProtocol.GrpcProtocolWriter
 import akka.grpc.ProtobufSerializer
 import akka.grpc.scaladsl.GrpcMarshalling
-import akka.grpc.internal.GrpcProtocolNative
 import akka.http.scaladsl.marshalling.Marshaller
 import akka.http.scaladsl.marshalling.ToResponseMarshaller
 import akka.http.scaladsl.model.HttpRequest
@@ -28,14 +26,14 @@ object @{service.name}Marshallers {
   }
 
   implicit def unmarshaller[T](implicit serializer: ProtobufSerializer[T], mat: Materializer): FromRequestUnmarshaller[T] =
-    Unmarshaller((ec: ExecutionContext) => (req: HttpRequest) => GrpcMarshalling.unmarshal(req)(serializer, mat))
+    Unmarshaller((_: ExecutionContext) => (req: HttpRequest) => GrpcMarshalling.unmarshal(req)(serializer, mat))
 
   implicit def toSourceUnmarshaller[T](implicit serializer: ProtobufSerializer[T], mat: Materializer): FromRequestUnmarshaller[akka.stream.scaladsl.Source[T, akka.NotUsed]] =
-    Unmarshaller((ec: ExecutionContext) => (req: HttpRequest) => GrpcMarshalling.unmarshalStream(req)(serializer, mat))
+    Unmarshaller((_: ExecutionContext) => (req: HttpRequest) => GrpcMarshalling.unmarshalStream(req)(serializer, mat))
 
-  implicit def marshaller[T](implicit serializer: ProtobufSerializer[T], mat: Materializer, writer: GrpcProtocolWriter, system: ActorSystem): ToResponseMarshaller[T] =
-    Marshaller.opaque((response: T) => GrpcMarshalling.marshal(response)(serializer, mat, writer, system))
+  implicit def marshaller[T](implicit serializer: ProtobufSerializer[T], writer: GrpcProtocolWriter, system: ActorSystem): ToResponseMarshaller[T] =
+    Marshaller.opaque((response: T) => GrpcMarshalling.marshal(response)(serializer, writer, system))
 
-  implicit def fromSourceMarshaller[T](implicit serializer: ProtobufSerializer[T], mat: Materializer, writer: GrpcProtocolWriter, system: ActorSystem): ToResponseMarshaller[akka.stream.scaladsl.Source[T, akka.NotUsed]] =
-    Marshaller.opaque((response: akka.stream.scaladsl.Source[T, akka.NotUsed]) => GrpcMarshalling.marshalStream(response)(serializer, mat, writer, system))
+  implicit def fromSourceMarshaller[T](implicit serializer: ProtobufSerializer[T], writer: GrpcProtocolWriter, system: ActorSystem): ToResponseMarshaller[akka.stream.scaladsl.Source[T, akka.NotUsed]] =
+    Marshaller.opaque((response: akka.stream.scaladsl.Source[T, akka.NotUsed]) => GrpcMarshalling.marshalStream(response)(serializer, writer, system))
 }

codegen/src/main/twirl/templates/ScalaServer/Handler.scala.txt

@@ -90,7 +90,7 @@ import akka.stream.Materializer
                 @{if(powerApis) { "val metadata = MetadataBuilder.fromHeaders(request.headers)" } else { "" }}
                 @{method.unmarshal}(request.entity.dataBytes)(@method.deserializer.name, mat, reader)
                   .@{if(method.outputStreaming) { "map" } else { "flatMap" }}(implementation.@{method.name}(_@{if(powerApis) { ", metadata" } else { "" }}))
-                  .map(e => @{method.marshal}(e, eHandler)(@method.serializer.name, mat, writer, system))
+                  .map(e => @{method.marshal}(e, eHandler)(@method.serializer.name, writer, system))
             }
             case m => scala.concurrent.Future.failed(new NotImplementedError(s"Not implemented: $m"))
           })

interop-tests/src/main/scala/akka/grpc/interop/AkkaGrpcServerScala.scala

@@ -31,7 +31,6 @@ case class AkkaGrpcServerScala(serverHandlerFactory: Materializer => ActorSystem
   override def start() = {
     implicit val sys = ActorSystem()
     implicit val mat = ActorMaterializer()
-    implicit val ec = sys.dispatcher
 
     val testService = serverHandlerFactory(mat)(sys)
 

interop-tests/src/test/scala/akka/grpc/interop/AkkaGrpcScalaClientTester.scala

@@ -20,7 +20,6 @@ import org.junit.Assert._
 
 import scala.concurrent.duration._
 import scala.concurrent.{ Await, Future }
-import scala.util.Failure
 import scala.util.control.NoStackTrace
 
 /**

interop-tests/src/test/scala/akka/grpc/interop/TestServiceImpl.scala

@@ -12,7 +12,6 @@ import com.google.protobuf.ByteString
 import io.grpc.Status
 import io.grpc.testing.integration.empty.Empty
 
-import scala.collection.immutable
 import scala.concurrent.{ ExecutionContext, Future }
 
 // Generated by our plugin

interop-tests/src/test/scala/akka/grpc/scaladsl/GrpcExceptionHandlerSpec.scala

@@ -8,8 +8,8 @@ import scala.concurrent.Future
 
 import akka.actor.ActorSystem
 
-import akka.grpc.{ GrpcServiceException, Identity }
-import akka.grpc.internal.{ GrpcEntityHelpers, GrpcProtocolNative, GrpcRequestHelpers }
+import akka.grpc.Identity
+import akka.grpc.internal.{ GrpcProtocolNative, GrpcRequestHelpers }
 import akka.grpc.scaladsl.headers.`Status`
 import akka.http.scaladsl.model.{ HttpEntity, HttpRequest, HttpResponse }
 import akka.http.scaladsl.model.HttpEntity.{ Chunked, LastChunk }
@@ -44,7 +44,7 @@ class GrpcExceptionHandlerSpec
         .recoverWith(GrpcExceptionHandler.defaultHandler)
 
       result.futureValue.entity match {
-        case Chunked(contentType, chunks) =>
+        case Chunked(_, chunks) =>
           chunks.runWith(Sink.seq).futureValue match {
             case Seq(LastChunk("", List(`Status`("3")))) => // ok
           }
@@ -130,7 +130,6 @@ class GrpcExceptionHandlerSpec
     }
 
     "return the correct user-supplied status for a streaming call" in {
-      import akka.http.scaladsl.client.RequestBuilding._
       implicit val serializer =
         example.myapp.helloworld.grpc.helloworld.GreeterService.Serializers.HelloRequestSerializer
       implicit val writer = GrpcProtocolNative.newWriter(Identity)

maven-plugin/src/main/scala/akka/grpc/maven/GenerateMojo.scala

@@ -69,7 +69,7 @@ object GenerateMojo {
       case "scala" => Scala
       case "java"  => Java
       case unknown =>
-        throw new IllegalArgumentException("[$unknown] is not a supported language, supported are java or scala")
+        throw new IllegalArgumentException("[" + unknown + "] is not a supported language, supported are java or scala")
     }
 
   /**

plugin-tester-java/src/test/scala/example/myapp/helloworld/JGreeterServiceSpec.scala

@@ -8,7 +8,6 @@ import scala.concurrent.Await
 
 import org.scalatest.BeforeAndAfterAll
 import scala.concurrent.duration._
-import scala.language.postfixOps
 
 import akka.actor.ActorSystem
 import akka.grpc.GrpcClientSettings

project/Common.scala

@@ -30,15 +30,24 @@ object Common extends AutoPlugin {
   val silencerVersion = "1.6.0"
   override lazy val projectSettings = Seq(
     projectInfoVersion := (if (isSnapshot.value) "snapshot" else version.value),
-    scalacOptions ++= List("-unchecked", "-deprecation", "-language:_", "-Xfatal-warnings", "-encoding", "UTF-8"),
+    scalacOptions ++= List(
+        "-unchecked",
+        "-deprecation",
+        "-language:_",
+        "-Xfatal-warnings",
+        "-Ywarn-unused",
+        "-encoding",
+        "UTF-8"),
     Compile / scalacOptions ++= Seq(
         // generated code for methods/fields marked 'deprecated'
         "-P:silencer:globalFilters=Marked as deprecated in proto file",
         // generated scaladoc sometimes has this problem
         "-P:silencer:globalFilters=unbalanced or unclosed heading",
         // deprecated in 2.13, but used as long as we support 2.12
         "-P:silencer:globalFilters=Use `scala.jdk.CollectionConverters` instead",
-        "-P:silencer:globalFilters=Use LazyList instead of Stream"),
+        "-P:silencer:globalFilters=Use LazyList instead of Stream",
+        // ignore imports in templates
+        "-P:silencer:pathFilters=.*.txt"),
     javacOptions ++= List("-Xlint:unchecked", "-Xlint:deprecation"),
     Compile / doc / scalacOptions := scalacOptions.value ++ Seq(
         "-doc-title",

project/ReflectiveCodeGen.scala

@@ -104,13 +104,12 @@ object ReflectiveCodeGen extends AutoPlugin {
           |val languages: Seq[AkkaGrpc.Language] = Seq($languages)
           |val sources: Seq[AkkaGrpc.GeneratedSource] = Seq($sources)
           |val scalaBinaryVersion = ScalaBinaryVersion("$scalaBinaryVersion")
-          |val generatorSettings: Seq[String] = Seq($generatorSettings1)
           |
           |val logger = akka.grpc.gen.StdoutLogger
           |
           |(targetPath: java.io.File, settings: Seq[String]) => {
           |  val generators =
-          |    AkkaGrpcPlugin.generatorsFor(sources, languages, generatorSettings, scalaBinaryVersion, logger) ++
+          |    AkkaGrpcPlugin.generatorsFor(sources, languages, scalaBinaryVersion, logger) ++
           |    Seq($extraGenerators).map(gen => AkkaGrpcPlugin.toGenerator(gen, scalaBinaryVersion, akka.grpc.gen.StdoutLogger))
           |  AkkaGrpcPlugin.targetsFor(targetPath, settings, generators)
           |}

runtime/src/main/mima-filters/0.7.3.backwards.excludes/847-unused-values.backwards.excludes

@@ -0,0 +1,6 @@
+ProblemFilters.exclude[DirectMissingMethodProblem]("akka.grpc.javadsl.GrpcMarshalling.marshal*")
+ProblemFilters.exclude[DirectMissingMethodProblem]("akka.grpc.scaladsl.GrpcMarshalling.marshal*")
+ProblemFilters.exclude[DirectMissingMethodProblem]("akka.grpc.internal.ChannelUtils.closeCS")
+ProblemFilters.exclude[DirectMissingMethodProblem]("akka.grpc.internal.ChannelUtils.close")
+ProblemFilters.exclude[DirectMissingMethodProblem]("akka.grpc.internal.GrpcResponseHelpers.apply")
+ProblemFilters.exclude[IncompatibleMethTypeProblem]("akka.grpc.internal.GrpcResponseHelpers.apply")

runtime/src/main/scala/akka/grpc/GrpcClientSettings.scala

@@ -195,18 +195,18 @@ final class GrpcClientSettings private (
     val serviceDiscovery: ServiceDiscovery,
     val defaultPort: Int,
     val resolveTimeout: FiniteDuration,
-    val servicePortName: Option[String] = None,
-    val serviceProtocol: Option[String] = None,
+    val servicePortName: Option[String],
+    val serviceProtocol: Option[String],
     val creationAttempts: Integer,
     val creationDelay: FiniteDuration,
-    val connectionAttempts: Option[Int] = None,
-    val callCredentials: Option[CallCredentials] = None,
-    val overrideAuthority: Option[String] = None,
-    val sslContext: Option[SSLContext] = None,
-    val deadline: Duration = Duration.Undefined,
-    val userAgent: Option[String] = None,
-    val useTls: Boolean = true,
-    val grpcLoadBalancingType: Option[String] = None,
+    val connectionAttempts: Option[Int],
+    val callCredentials: Option[CallCredentials],
+    val overrideAuthority: Option[String],
+    val sslContext: Option[SSLContext],
+    val deadline: Duration,
+    val userAgent: Option[String],
+    val useTls: Boolean,
+    val grpcLoadBalancingType: Option[String],
     val channelBuilderOverrides: NettyChannelBuilder => NettyChannelBuilder = identity) {
 
   /**

runtime/src/main/scala/akka/grpc/internal/AbstractGrpcProtocol.scala

@@ -84,7 +84,6 @@ object AbstractGrpcProtocol {
       Flow[Frame].map(encodeFrame))
 
   def reader(
-      protocol: GrpcProtocol,
       codec: Codec,
       decodeFrame: (Int, ByteString) => Frame,
       flowAdapter: Flow[ByteString, Frame, NotUsed] => Flow[ByteString, Frame, NotUsed] = identity)

runtime/src/main/scala/akka/grpc/internal/AkkaDiscoveryNameResolver.scala

@@ -4,7 +4,7 @@
 
 package akka.grpc.internal
 
-import java.net.{ InetAddress, InetSocketAddress, SocketAddress, URI, UnknownHostException }
+import java.net.{ InetAddress, InetSocketAddress, UnknownHostException }
 
 import akka.discovery.ServiceDiscovery.ResolvedTarget
 import akka.discovery.{ Lookup, ServiceDiscovery }

runtime/src/main/scala/akka/grpc/internal/AkkaGrpcClientFactory.scala

@@ -9,7 +9,6 @@ import scala.reflect.{ classTag, ClassTag }
 import akka.grpc.GrpcClientSettings
 import akka.grpc.scaladsl.AkkaGrpcClient
 import akka.stream.Materializer
-import language.reflectiveCalls
 
 object AkkaGrpcClientFactory {
   def create[T <: AkkaGrpcClient: ClassTag](

runtime/src/main/scala/akka/grpc/internal/AkkaNettyGrpcClientGraphStage.scala

@@ -4,16 +4,13 @@
 
 package akka.grpc.internal
 
-import java.util.concurrent.CompletionStage
-
 import akka.annotation.InternalApi
 import akka.dispatch.ExecutionContexts
 import akka.grpc.GrpcResponseMetadata
 import akka.stream
 import akka.stream.{ Attributes => _, _ }
 import akka.stream.stage._
 import io.grpc._
-import io.grpc.stub.StreamObserver
 
 import scala.concurrent.{ Future, Promise }
 import scala.compat.java8.FutureConverters._

runtime/src/main/scala/akka/grpc/internal/ChannelUtils.scala

@@ -12,7 +12,7 @@ import akka.event.LoggingAdapter
 import io.grpc.{ ConnectivityState, ManagedChannel }
 
 import scala.compat.java8.FutureConverters._
-import scala.concurrent.{ ExecutionContext, Future, Promise }
+import scala.concurrent.{ Future, Promise }
 
 /**
  * Used to indicate that a gRPC client can not establish a connection
@@ -33,7 +33,7 @@ object ChannelUtils {
    * INTERNAL API
    */
   @InternalApi
-  def close(internalChannel: InternalChannel)(implicit ec: ExecutionContext): Future[Done] = {
+  def close(internalChannel: InternalChannel): Future[Done] = {
     internalChannel.managedChannel.shutdown()
     internalChannel.done
   }
@@ -42,7 +42,7 @@ object ChannelUtils {
    * INTERNAL API
    */
   @InternalApi
-  def closeCS(internalChannel: InternalChannel)(implicit ec: ExecutionContext): CompletionStage[Done] =
+  def closeCS(internalChannel: InternalChannel): CompletionStage[Done] =
     close(internalChannel).toJava
 
   /**

runtime/src/main/scala/akka/grpc/internal/GrpcEntityHelpers.scala

@@ -13,7 +13,6 @@ import akka.grpc.scaladsl.{ headers, BytesEntry, Metadata, StringEntry }
 import akka.http.scaladsl.model.HttpEntity.ChunkStreamPart
 import akka.http.scaladsl.model.HttpHeader
 import akka.http.scaladsl.model.headers.RawHeader
-import akka.stream.Materializer
 import akka.stream.scaladsl.Source
 import io.grpc.Status
 
@@ -25,7 +24,6 @@ object GrpcEntityHelpers {
       trail: Source[TrailerFrame, NotUsed],
       eHandler: ActorSystem => PartialFunction[Throwable, Trailers])(
       implicit m: ProtobufSerializer[T],
-      mat: Materializer,
       writer: GrpcProtocolWriter,
       system: ActorSystem): Source[ChunkStreamPart, NotUsed] = {
     chunks(e, trail).recover {
@@ -38,18 +36,12 @@ object GrpcEntityHelpers {
     }
   }
 
-  def apply[T](e: T)(
-      implicit m: ProtobufSerializer[T],
-      mat: Materializer,
-      writer: GrpcProtocolWriter,
-      system: ActorSystem): Source[ChunkStreamPart, NotUsed] =
+  def apply[T](e: T)(implicit m: ProtobufSerializer[T], writer: GrpcProtocolWriter): Source[ChunkStreamPart, NotUsed] =
     chunks(Source.single(e), Source.empty)
 
   private def chunks[T](e: Source[T, NotUsed], trail: Source[Frame, NotUsed])(
       implicit m: ProtobufSerializer[T],
-      mat: Materializer,
-      writer: GrpcProtocolWriter,
-      system: ActorSystem): Source[ChunkStreamPart, NotUsed] =
+      writer: GrpcProtocolWriter): Source[ChunkStreamPart, NotUsed] =
     e.map { msg => DataFrame(m.serialize(msg)) }.concat(trail).via(writer.frameEncoder)
 
   def trailer(status: Status): TrailerFrame =