RPCCompanion convenience abstract class designed for good ScalaJS DCE

Author: ghik

commons-akka/src/main/scala/com/avsystem/commons/rpc/akka/AkkaRPCFramework.scala

@@ -17,13 +17,15 @@ import com.avsystem.commons.serialization.GenCodec
 object AkkaRPCFramework extends GetterRPCFramework with ProcedureRPCFramework with FunctionRPCFramework with MonixRPCFramework {
   trait RawRPC extends GetterRawRPC with ProcedureRawRPC with FunctionRawRPC with MonixRawRPC
 
-  override type RawValue = ByteString
+  type RawValue = ByteString
 
-  override type Reader[T] = GenCodec[T]
-  override type Writer[T] = GenCodec[T]
+  type Reader[T] = GenCodec[T]
+  type Writer[T] = GenCodec[T]
+  type ParamTypeMetadata[T] = DummyImplicit
+  type ResultTypeMetadata[T] = DummyImplicit
 
-  override def read[T: Reader](raw: RawValue): T = GenCodec.read[T](new ByteStringLinearInput(raw))
-  override def write[T: Writer](value: T): RawValue = {
+  def read[T: Reader](raw: RawValue): T = GenCodec.read[T](new ByteStringLinearInput(raw))
+  def write[T: Writer](value: T): RawValue = {
     val output = new ByteStringLinearOutput(ByteString.newBuilder)
     GenCodec.write[T](output, value)
     output.result

commons-akka/src/test/scala/com/avsystem/commons/rpc/akka/TestRPC.scala

@@ -2,6 +2,7 @@ package com.avsystem.commons
 package rpc.akka
 
 import com.avsystem.commons.rpc.RPC
+import com.avsystem.commons.rpc.akka.AkkaRPCFramework._
 import monix.reactive.Observable
 
 
@@ -15,8 +16,14 @@ trait TestRPC {
   def stream: Observable[Int]
   def inner: InnerRPC
 }
+object TestRPC {
+  implicit val fullRPCInfo: BaseFullRPCInfo[TestRPC] = materializeFullInfo
+}
 
 @RPC
 trait InnerRPC {
   def innerFire(): Unit
-}
+}
+object InnerRPC {
+  implicit val fullRPCInfo: BaseFullRPCInfo[InnerRPC] = materializeFullInfo
+}

commons-benchmark/src/main/scala/com/avsystem/commons/rpc/akka/AkkaRPCFrameworkBenchmark.scala

@@ -5,14 +5,15 @@ import java.util.concurrent.atomic.AtomicInteger
 
 import akka.actor.{ActorPath, ActorSystem}
 import com.avsystem.commons.rpc.RPC
+import com.avsystem.commons.rpc.akka.AkkaRPCFramework._
 import com.typesafe.config.{Config, ConfigFactory}
 import monix.reactive.Observable
 import org.openjdk.jmh.annotations.{Benchmark, BenchmarkMode, Fork, Measurement, Mode, Scope, Setup, State, TearDown, Warmup}
 import org.openjdk.jmh.infra.Blackhole
 
+import scala.concurrent.Await
 import scala.concurrent.ExecutionContext.Implicits.global
 import scala.concurrent.duration._
-import scala.concurrent.Await
 
 /**
   * @author Wojciech Milewski
@@ -128,8 +129,14 @@ trait TestRPC {
   def stream: Observable[Int]
   def inner: InnerRPC
 }
+object TestRPC {
+  implicit val fullRPCInfo: BaseFullRPCInfo[TestRPC] = materializeFullInfo
+}
 
 @RPC
 trait InnerRPC {
   def innerFire(): Unit
-}
+}
+object InnerRPC {
+  implicit val fullRPCInfo: BaseFullRPCInfo[InnerRPC] = materializeFullInfo
+}

commons-jetty/src/test/scala/com/avsystem/commons/jetty/rpc/RPCMain.scala

@@ -10,16 +10,54 @@ import upickle.Js
   * @author MKej
   */
 object RPCMain {
+  object jettyFramework extends JettyRPCFramework {
+    type RawValue = Js.Value
+    type Reader[T] = upickle.default.Reader[T]
+    type Writer[T] = upickle.default.Writer[T]
+    type ResultTypeMetadata[T] = DummyImplicit
+    type ParamTypeMetadata[T] = DummyImplicit
+
+    def valueToJson(value: RawValue) = upickle.json.write(value)
+    def jsonToValue(json: String) = upickle.json.read(json)
+    def argsToJson(args: List[List[RawValue]]) = upickle.json.write(argsToJsArr(args))
+    def jsonToArgs(json: String) = jsArrToArgs(upickle.json.read(json))
+
+    def read[T: Reader](raw: RawValue): T = upickle.default.readJs[T](raw)
+    def write[T: Writer](value: T): RawValue = upickle.default.writeJs[T](value)
+
+    def argsToJsArr(argLists: List[List[Js.Value]]): Js.Value = {
+      Js.Arr(argLists map { args => Js.Arr(args: _*) }: _*)
+    }
+
+    def jsArrToArgs(value: Js.Value): List[List[Js.Value]] = {
+      value match {
+        case array: Js.Arr =>
+          (array.value map {
+            case nestedArray: Js.Arr => nestedArray.value.toList
+            case _ => List()
+          }).toList
+        case _ => List()
+      }
+    }
+  }
+  import jettyFramework._
+
   @RPC trait SomeApi {
     def keks: Future[Int]
     def isTop(keks: Int): Future[Boolean]
     def topper: Topper
   }
+  object SomeApi {
+    implicit val fullRPCInfo: BaseFullRPCInfo[SomeApi] = materializeFullInfo
+  }
 
   @RPC trait Topper {
     def initialize: Future[Unit]
     def topKeks: Future[Int]
   }
+  object Topper {
+    implicit val fullRPCInfo: BaseFullRPCInfo[Topper] = materializeFullInfo
+  }
 
   def main(args: Array[String]): Unit = {
     import scala.concurrent.ExecutionContext.Implicits.global
@@ -33,35 +71,6 @@ object RPCMain {
       }
     }
 
-    object jettyFramework extends JettyRPCFramework {
-      type RawValue = Js.Value
-      type Reader[T] = upickle.default.Reader[T]
-      type Writer[T] = upickle.default.Writer[T]
-
-      def valueToJson(value: RawValue) = upickle.json.write(value)
-      def jsonToValue(json: String) = upickle.json.read(json)
-      def argsToJson(args: List[List[RawValue]]) = upickle.json.write(argsToJsArr(args))
-      def jsonToArgs(json: String) = jsArrToArgs(upickle.json.read(json))
-
-      def read[T: Reader](raw: RawValue): T = upickle.default.readJs[T](raw)
-      def write[T: Writer](value: T): RawValue = upickle.default.writeJs[T](value)
-
-      def argsToJsArr(argLists: List[List[Js.Value]]): Js.Value = {
-        Js.Arr(argLists map { args => Js.Arr(args: _*) }: _*)
-      }
-
-      def jsArrToArgs(value: Js.Value): List[List[Js.Value]] = {
-        value match {
-          case array: Js.Arr =>
-            (array.value map {
-              case nestedArray: Js.Arr => nestedArray.value.toList
-              case _ => List()
-            }).toList
-          case _ => List()
-        }
-      }
-    }
-
     val port = 1337
 
     val server = new Server(port)

commons-macros/src/main/scala/com/avsystem/commons/macros/MacroCommons.scala

@@ -31,6 +31,9 @@ trait MacroCommons {
   final val ImplicitsObj = q"$CommonsPackage.misc.Implicits"
   final val AnnotationAggregateType = getType(tq"$CommonsPackage.annotation.AnnotationAggregate")
 
+  final lazy val isScalaJs =
+    definitions.ScalaPackageClass.toType.member(TermName("scalajs")) != NoSymbol
+
   final lazy val ownerChain = {
     val sym = c.typecheck(q"val ${c.freshName(TermName(""))} = null").symbol
     Iterator.iterate(sym)(_.owner).takeWhile(_ != NoSymbol).drop(1).toList
@@ -49,6 +52,11 @@ trait MacroCommons {
       c.echo(c.enclosingPosition, show(t))
       t
     }
+
+    def asStatList: List[Tree] = t match {
+      case Block(stats, expr) => stats :+ expr
+      case _ => List(t)
+    }
   }
 
   def superSymbols(s: Symbol): List[Symbol] = s match {
@@ -486,14 +494,6 @@ trait MacroCommons {
     }
   }
 
-  def inferOrMaterialize(typeClass: Type)(materialize: => Tree): Tree =
-    if (c.macroApplication.symbol.isImplicit)
-      c.inferImplicitValue(typeClass, withMacrosDisabled = true) match {
-        case EmptyTree => materialize
-        case tree => tree
-      }
-    else materialize
-
   def abortOnTypecheckException[T](expr: => T): T =
     try expr catch {
       case TypecheckException(pos, msg) => abort(msg)

commons-macros/src/main/scala/com/avsystem/commons/macros/misc/MiscMacros.scala

@@ -48,4 +48,7 @@ class MiscMacros(ctx: blackbox.Context) extends AbstractMacroCommons(ctx) {
       )
      """
   }
+
+  def crossImpl(forJvm: Tree, forJs: Tree): Tree =
+    if (isScalaJs) forJs else forJvm
 }