internal: Fix Scala 3 related warnings (#3111)

- Fix warnings
- Drop HttpClient[Req, Resp, F] usage in Scala 3 #2440

airframe-benchmark/src/main/scala/wvlet/airframe/benchmark/http/ServiceAsyncClient.scala

@@ -20,21 +20,20 @@ import wvlet.airframe.http.client.AsyncClient
 import wvlet.airframe.rx.Rx
 import wvlet.airframe.surface.Surface
 
-import scala.language.higherKinds
-
-class ServiceClient[F[_], Req, Resp](private val client: HttpClient[F, Req, Resp]) extends AutoCloseable {
-  override def close(): Unit              = { client.close() }
-  def getClient: HttpClient[F, Req, Resp] = client
-  object Greeter {
-    def hello(name: String, requestFilter: Req => Req = identity): F[String] = {
-      client.postOps[Map[String, Any], String](
-        resourcePath = s"/wvlet.airframe.benchmark.http.Greeter/hello",
-        Map("name" -> name),
-        requestFilter = requestFilter
-      )
-    }
-  }
-}
+//import scala.language.higherKinds
+//class ServiceClient[F[_], Req, Resp](private val client: HttpClient[F, Req, Resp]) extends AutoCloseable {
+//  override def close(): Unit              = { client.close() }
+//  def getClient: HttpClient[F, Req, Resp] = client
+//  object Greeter {
+//    def hello(name: String, requestFilter: Req => Req = identity): F[String] = {
+//      client.postOps[Map[String, Any], String](
+//        resourcePath = s"/wvlet.airframe.benchmark.http.Greeter/hello",
+//        Map("name" -> name),
+//        requestFilter = requestFilter
+//      )
+//    }
+//  }
+//}
 
 class NewServiceAsyncClient(private val client: AsyncClient) extends AutoCloseable {
   override def close(): Unit = { client.close() }

airframe-benchmark/src/main/scala/wvlet/airframe/benchmark/http/ServiceSyncClient.scala

@@ -13,26 +13,22 @@
  */
 package wvlet.airframe.benchmark.http
 
-/**
-  */
 import wvlet.airframe.http._
 import wvlet.airframe.http.client.SyncClient
 
-import scala.collection.immutable.Map
-
-class ServiceSyncClient[Req, Resp](private val client: HttpSyncClient[Req, Resp]) extends AutoCloseable {
-  override def close(): Unit               = { client.close() }
-  def getClient: HttpSyncClient[Req, Resp] = client
-  object Greeter {
-    def hello(name: String, requestFilter: Req => Req = identity): String = {
-      client.postOps[Map[String, Any], String](
-        resourcePath = s"/wvlet.airframe.benchmark.http.Greeter/hello",
-        Map("name" -> name),
-        requestFilter = requestFilter
-      )
-    }
-  }
-}
+//class ServiceSyncClient[Req, Resp](private val client: HttpSyncClient[Req, Resp]) extends AutoCloseable {
+//  override def close(): Unit               = { client.close() }
+//  def getClient: HttpSyncClient[Req, Resp] = client
+//  object Greeter {
+//    def hello(name: String, requestFilter: Req => Req = identity): String = {
+//      client.postOps[Map[String, Any], String](
+//        resourcePath = s"/wvlet.airframe.benchmark.http.Greeter/hello",
+//        Map("name" -> name),
+//        requestFilter = requestFilter
+//      )
+//    }
+//  }
+//}
 
 class NewServiceSyncClient(private val client: SyncClient) extends AutoCloseable {
   override def close(): Unit = { client.close() }

airframe-codec/src/main/scala/wvlet/airframe/codec/ThrowableCodec.scala

@@ -69,7 +69,7 @@ object GenericException {
         lineNumber = x.getLineNumber
       )
     }
-    stackTrace
+    stackTrace.toIndexedSeq
   }
 
   def fromThrowable(e: Throwable, seen: Set[Throwable] = Set.empty): GenericException = {

airframe-control/.jvm/src/main/scala/wvlet/airframe/control/Shell.scala

@@ -66,7 +66,7 @@ object Shell extends LogSupport {
     // retrieve child processes
     val pb = prepareProcessBuilder(s"ps -o pid -p $pid | sed 1d", inheritIO = true)
     // TODO: Use lazyLines when Scala 2.12 dropped
-    for (line <- Process(pb).lineStream) {
+    for (line <- Process(pb).!!.linesIterator) {
       val childPID = line.trim.toInt
       killTree(childPID, signal)
     }

airframe-di/src/main/scala-3/wvlet/airframe/package.scala

@@ -77,7 +77,7 @@ package object airframe {
     }
     val isTaggedType = a.fullName.startsWith("wvlet.airframe.surface.tag.")
     val isSealedType = a.flags.is(Flags.Sealed)
-    val isStatic     = a.flags.is(Flags.Static)
+    val isStatic     = a.flags.is(Flags.JavaStatic)
     val isLocal      = a.flags.is(Flags.Local)
     val isTrait      = a.flags.is(Flags.Trait)
 

airframe-http-finagle/src/main/scala/wvlet/airframe/http/finagle/FinagleClient.scala

@@ -14,14 +14,14 @@
 package wvlet.airframe.http.finagle
 
 import java.util.concurrent.TimeUnit
-
 import com.twitter.finagle.http.{Request, Response}
 import com.twitter.finagle.{Http, Service, http}
 import com.twitter.util._
 import wvlet.airframe.Design
 import wvlet.airframe.codec.{MessageCodec, MessageCodecFactory}
 import wvlet.airframe.control.Retry.RetryContext
 import wvlet.airframe.http._
+import wvlet.airframe.http.client.HttpClients
 import wvlet.airframe.http.internal.HttpResponseBodyCodec
 import wvlet.airframe.surface.Surface
 import wvlet.log.LogSupport
@@ -250,7 +250,7 @@ class FinagleClient(address: ServerAddress, config: FinagleClientConfig)
   ): Future[Resource] = {
 
     val resourceSurface = Surface.of[ResourceRequest]
-    val path            = HttpClient.buildResourceUri(resourcePath, resourceRequest, resourceSurface)
+    val path            = HttpClients.buildResourceUri(resourcePath, resourceRequest, resourceSurface)
     convert[Resource](send(newRequest(HttpMethod.GET, path), requestFilter))
   }
   override def list[OperationResponse: ru.TypeTag](
@@ -375,7 +375,7 @@ object FinagleClient extends LogSupport {
     x.withSessionQualifier.noFailureAccrual
   }
   def defaultRetryContext: RetryContext = {
-    HttpClient.defaultHttpClientRetry[http.Request, http.Response]
+    HttpClients.defaultHttpClientRetry[http.Request, http.Response]
   }
   def newClient(hostAndPort: String, config: FinagleClientConfig = FinagleClientConfig()): FinagleClient = {
     new FinagleClient(address = ServerAddress(hostAndPort), config)

airframe-http-okhttp/src/main/scala/wvlet/airframe/http/okhttp/OkHttp.scala

@@ -13,9 +13,8 @@
  */
 package wvlet.airframe.http.okhttp
 
-import wvlet.airframe.control.Retry.RetryContext
 import wvlet.airframe.http.client.{HttpChannel, HttpClientBackend, HttpClientConfig}
-import wvlet.airframe.http.{Http, HttpClient, ServerAddress}
+import wvlet.airframe.http.{Http, ServerAddress}
 
 object OkHttp {
   def client: HttpClientConfig =

airframe-http/.js/src/main/scala/wvlet/airframe/http/client/JSHttpClientBackend.scala

@@ -15,12 +15,13 @@ package wvlet.airframe.http.client
 
 import wvlet.airframe.control.Retry
 import wvlet.airframe.http.HttpMessage.{Request, Response}
-import wvlet.airframe.http.{HttpClient, HttpClientException, ServerAddress}
+import wvlet.airframe.http.{HttpClientException, ServerAddress}
+import wvlet.airframe.http.client.HttpClients
 
 object JSHttpClientBackend extends HttpClientBackend {
 
   override def defaultRequestRetryer: Retry.RetryContext = {
-    HttpClient
+    HttpClients
       .baseHttpClientRetry[Request, Response]
       // defaultHttpClientRetry has many JVM specific exception classifiers,
       // so we need to use a simple one for Scala.js

airframe-http/.jvm/src/test/scala/wvlet/airframe/http/HttpClientTest.scala

@@ -23,7 +23,7 @@ import wvlet.log.Logger
 /**
   */
 class HttpClientTest extends AirSpec {
-  import HttpClient._
+  import wvlet.airframe.http.client.HttpClients._
   abstract class RetryTest(expectedRetryCount: Int, expectedExecCount: Int) {
     val retryer = defaultHttpClientRetry[HttpMessage.Request, HttpMessage.Response]
       .withBackOff(initialIntervalMillis = 0)

airframe-http/src/main/scala/wvlet/airframe/http/HttpClient.scala → airframe-http/src/main/scala-2/wvlet/airframe/http/HttpClient.scala

@@ -15,9 +15,10 @@ package wvlet.airframe.http
 import wvlet.airframe.codec.MessageCodec
 import wvlet.airframe.control.Retry
 import wvlet.airframe.control.Retry.RetryContext
-import wvlet.airframe.http.HttpClient.urlEncode
+import wvlet.airframe.http.client.HttpClients.urlEncode
 import wvlet.airframe.http.HttpMessage.{Request, Response}
 import wvlet.airframe.http.internal.HttpResponseBodyCodec
+import wvlet.airframe.http.client.HttpClients.urlEncode
 import wvlet.airframe.json.JSON.{JSONArray, JSONObject}
 import wvlet.airframe.surface.Surface
 import wvlet.log.LogSupport
@@ -150,88 +151,4 @@ class HttpSyncClientAdapter[F[_], Req, Resp](asyncClient: HttpClient[F, Req, Res
   }
 }
 
-object HttpClient extends LogSupport {
-
-  private[http] def baseHttpClientRetry[Req: HttpRequestAdapter: ClassTag, Resp: HttpResponseAdapter]: RetryContext = {
-    Retry
-      .withJitter(maxRetry = 15)
-      .withResultClassifier(HttpClientException.classifyHttpResponse[Resp])
-      .beforeRetry(defaultBeforeRetryAction[Req])
-  }
-
-  def defaultHttpClientRetry[Req: HttpRequestAdapter: ClassTag, Resp: HttpResponseAdapter]: RetryContext = {
-    baseHttpClientRetry[Req, Resp]
-      // JVM specific error handler
-      .withErrorClassifier(HttpClientException.classifyExecutionFailure)
-  }
-
-  def defaultBeforeRetryAction[Req: HttpRequestAdapter: ClassTag](ctx: RetryContext): Any = {
-    val cls = implicitly[ClassTag[Req]].runtimeClass
-
-    val errorMessage = ctx.context match {
-      case Some(r) if cls.isAssignableFrom(r.getClass) =>
-        val adapter = implicitly[HttpRequestAdapter[Req]]
-        val req     = r.asInstanceOf[Req]
-        val path    = adapter.pathOf(req)
-        s"Request to ${path} is failed: ${ctx.lastError.getMessage}"
-      case _ =>
-        s"Request is failed: ${ctx.lastError.getMessage}"
-    }
-
-    val nextWaitMillis = ctx.nextWaitMillis
-    warn(
-      f"[${ctx.retryCount}/${ctx.maxRetry}] ${errorMessage}. Retry the request in ${nextWaitMillis / 1000.0}%.3f sec."
-    )
-  }
-
-  def urlEncode(s: String): String = {
-    compat.urlEncode(s)
-  }
-
-  /**
-    * Generate a GET resource url by embedding the resource object into query parameters
-    * @param path
-    * @param resource
-    * @param resourceSurface
-    * @tparam Resource
-    * @return
-    */
-  private[http] def buildResourceUri[Resource](path: String, resource: Resource, resourceSurface: Surface): String = {
-    val queryParams    = HttpClient.flattenResourceToQueryParams(resource, resourceSurface)
-    val pathWithParams = new StringBuilder()
-    pathWithParams.append(path)
-    if (queryParams.nonEmpty) {
-      val queryParamString = queryParams.entries.map(x => s"${x.key}=${x.value}").mkString("&")
-      pathWithParams.append("?")
-      pathWithParams.append(queryParamString)
-    }
-    pathWithParams.result()
-  }
-
-  /**
-    * Flatten resource objects into query parameters for GET request
-    * @param resource
-    * @param resourceSurface
-    * @tparam Resource
-    * @return
-    */
-  private[http] def flattenResourceToQueryParams[Resource](
-      resource: Resource,
-      resourceSurface: Surface
-  ): HttpMultiMap = {
-    val resourceCodec = MessageCodec.ofSurface(resourceSurface).asInstanceOf[MessageCodec[Resource]]
-    val resourceJson  = Try(resourceCodec.toJSONObject(resource)).getOrElse(JSONObject.empty)
-
-    val queryParams = HttpMultiMap.newBuilder
-    resourceJson.v.map {
-      case (k, j @ JSONArray(_)) =>
-        queryParams += urlEncode(k) -> urlEncode(j.toJSON) // Flatten the JSON array value
-      case (k, j @ JSONObject(_)) =>
-        queryParams += urlEncode(k) -> urlEncode(j.toJSON) // Flatten the JSON object value
-      case (k, other) =>
-        queryParams += urlEncode(k) -> urlEncode(other.toString)
-    }
-    queryParams.result()
-  }
-
-}
+object HttpClient extends LogSupport {}