backed out NativeArray usage in GenCodecs for binary compatibility

Author: ghik

commons-core/src/main/scala/com/avsystem/commons/serialization/FieldValues.scala

@@ -1,24 +1,23 @@
 package com.avsystem.commons
 package serialization
 
-import com.avsystem.commons.misc.CrossUtils._
 import com.avsystem.commons.serialization.GenCodec.ReadFailure
 
 import scala.annotation.tailrec
 
 object FieldValues {
-  final val Empty = new FieldValues(newNativeArray(0), newNativeArray(0))
+  final val Empty = new FieldValues(new Array(0), new Array(0))
   private object NullMarker
 }
 final class FieldValues(
-  private val fieldNames: NativeArray[String], codecs: NativeArray[GenCodec[_]], ofWhat: OptArg[String] = OptArg.Empty) {
+  private val fieldNames: Array[String], codecs: Array[GenCodec[_]], ofWhat: OptArg[String] = OptArg.Empty) {
 
   @tailrec private def fieldIndex(fieldName: String, idx: Int): Int =
     if (idx >= fieldNames.length) -1
     else if (fieldNames(idx) == fieldName) idx
     else fieldIndex(fieldName, idx + 1)
 
-  private val values = newNativeArray[Any](fieldNames.length)
+  private val values = new Array[Any](fieldNames.length)
 
   import FieldValues._
 

commons-core/src/main/scala/com/avsystem/commons/serialization/macroCodecs.scala

@@ -1,7 +1,6 @@
 package com.avsystem.commons
 package serialization
 
-import com.avsystem.commons.misc.CrossUtils.NativeArray
 import com.avsystem.commons.serialization.GenCodec.{DefaultCaseField, NullSafeCodec, OOOFieldsObjectCodec, ObjectCodec, ReadFailure, WriteFailure}
 
 import scala.annotation.tailrec
@@ -18,10 +17,10 @@ class SingletonCodec[T <: Singleton](
 abstract class ApplyUnapplyCodec[T](
   protected val typeRepr: String,
   val nullable: Boolean,
-  fieldNames: NativeArray[String]
+  fieldNames: Array[String]
 ) extends OOOFieldsObjectCodec[T] with ErrorReportingCodec[T] {
 
-  protected def dependencies: NativeArray[GenCodec[_]]
+  protected def dependencies: Array[GenCodec[_]]
   protected def instantiate(fieldValues: FieldValues): T
 
   private[this] lazy val deps = dependencies
@@ -48,7 +47,7 @@ abstract class ApplyUnapplyCodec[T](
 abstract class ProductCodec[T <: Product](
   typeRepr: String,
   nullable: Boolean,
-  fieldNames: NativeArray[String]
+  fieldNames: Array[String]
 ) extends ApplyUnapplyCodec[T](typeRepr, nullable, fieldNames) {
   final def writeObject(output: ObjectOutput, value: T): Unit = {
     var i = 0
@@ -74,8 +73,8 @@ abstract class TransparentCodec[T, U](
 abstract class SealedHierarchyCodec[T](
   protected val typeRepr: String,
   val nullable: Boolean,
-  caseNames: NativeArray[String],
-  cases: NativeArray[Class[_ <: T]]
+  caseNames: Array[String],
+  cases: Array[Class[_ <: T]]
 ) extends ObjectCodec[T] with ErrorReportingCodec[T] {
 
   @tailrec protected final def caseIndexByValue(value: T, idx: Int = 0): Int =
@@ -92,11 +91,11 @@ abstract class SealedHierarchyCodec[T](
 abstract class NestedSealedHierarchyCodec[T](
   typeRepr: String,
   nullable: Boolean,
-  caseNames: NativeArray[String],
-  cases: NativeArray[Class[_ <: T]]
+  caseNames: Array[String],
+  cases: Array[Class[_ <: T]]
 ) extends SealedHierarchyCodec[T](typeRepr, nullable, caseNames, cases) {
 
-  protected def caseDependencies: NativeArray[GenCodec[_ <: T]]
+  protected def caseDependencies: Array[GenCodec[_ <: T]]
 
   private[this] lazy val caseDeps = caseDependencies
 
@@ -120,17 +119,17 @@ abstract class NestedSealedHierarchyCodec[T](
 abstract class FlatSealedHierarchyCodec[T](
   typeRepr: String,
   nullable: Boolean,
-  caseNames: NativeArray[String],
-  cases: NativeArray[Class[_ <: T]],
-  oooFieldNames: NativeArray[String],
+  caseNames: Array[String],
+  cases: Array[Class[_ <: T]],
+  oooFieldNames: Array[String],
   caseDependentFieldNames: Set[String],
   override protected val caseFieldName: String,
   defaultCaseIdx: Int,
   defaultCaseTransient: Boolean
 ) extends SealedHierarchyCodec[T](typeRepr, nullable, caseNames, cases) {
 
-  protected def oooDependencies: NativeArray[GenCodec[_]]
-  protected def caseDependencies: NativeArray[OOOFieldsObjectCodec[_ <: T]]
+  protected def oooDependencies: Array[GenCodec[_]]
+  protected def caseDependencies: Array[OOOFieldsObjectCodec[_ <: T]]
 
   private[this] lazy val oooDeps = oooDependencies
   private[this] lazy val caseDeps = caseDependencies

commons-macros/src/main/scala/com/avsystem/commons/macros/serialization/GenCodecMacros.scala

@@ -65,9 +65,9 @@ class GenCodecMacros(ctx: blackbox.Context) extends CodecMacroCommons(ctx) with
     addParams(q"$prefix.$sym", sym.typeSignature.paramLists)
   }
 
-  private def mkNativeArray[T: Liftable](elemTpe: Tree, elems: Seq[T]): Tree =
+  private def mkArray[T: Liftable](elemTpe: Tree, elems: Seq[T]): Tree =
     q"""
-       val res = $CommonsPackage.misc.CrossUtils.newNativeArray[$elemTpe](${elems.size})
+       val res = new $ScalaPkg.Array[$elemTpe](${elems.size})
        ..${elems.zipWithIndex.map({ case (e, i) => q"res($i) = $e" })}
        res
      """
@@ -257,11 +257,11 @@ class GenCodecMacros(ctx: blackbox.Context) extends CodecMacroCommons(ctx) with
         new $SerializationPkg.$baseClass[$dtpe](
           ${dtpe.toString},
           ${typeOf[Null] <:< dtpe},
-          ${mkNativeArray(StringCls, params.map(p => nameBySym(p.sym)))}
+          ${mkArray(StringCls, params.map(p => nameBySym(p.sym)))}
         ) {
           def dependencies = {
             ..$reusedDeps
-            ${mkNativeArray(tq"$GenCodecCls[_]", depsWithReusing)}
+            ${mkArray(tq"$GenCodecCls[_]", depsWithReusing)}
           }
           ..${generated.collect({ case (sym, depTpe) => generatedDepDeclaration(sym, depTpe) })}
           def instantiate(fieldValues: $SerializationPkg.FieldValues) =
@@ -289,10 +289,10 @@ class GenCodecMacros(ctx: blackbox.Context) extends CodecMacroCommons(ctx) with
       new $SerializationPkg.NestedSealedHierarchyCodec[$tpe](
         ${tpe.toString},
         ${typeOf[Null] <:< tpe},
-        ${mkNativeArray(StringCls, subtypes.map(st => targetNameBySym(st.sym)))},
-        ${mkNativeArray(tq"$ClassCls[_ <: $tpe]", subtypes.map(st => q"classOf[${st.tpe}]"))}
+        ${mkArray(StringCls, subtypes.map(st => targetNameBySym(st.sym)))},
+        ${mkArray(tq"$ClassCls[_ <: $tpe]", subtypes.map(st => q"classOf[${st.tpe}]"))}
       ) {
-        def caseDependencies = ${mkNativeArray(tq"$GenCodecCls[_ <: $tpe]", subtypes.map(_.instance))}
+        def caseDependencies = ${mkArray(tq"$GenCodecCls[_ <: $tpe]", subtypes.map(_.instance))}
       }
      """
   }
@@ -401,16 +401,16 @@ class GenCodecMacros(ctx: blackbox.Context) extends CodecMacroCommons(ctx) with
       new $SerializationPkg.FlatSealedHierarchyCodec[$tpe](
         ${tpe.toString},
         ${typeOf[Null] <:< tpe},
-        ${mkNativeArray(StringCls, caseInfos.map(_.caseName))},
-        ${mkNativeArray(tq"$ClassCls[_ <: $tpe]", caseInfos.map(_.classOf))},
-        ${mkNativeArray(StringCls, oooParamNames)},
+        ${mkArray(StringCls, caseInfos.map(_.caseName))},
+        ${mkArray(tq"$ClassCls[_ <: $tpe]", caseInfos.map(_.classOf))},
+        ${mkArray(StringCls, oooParamNames)},
         $SetObj(..$caseDependentFieldNames),
         $caseFieldName,
         ${defaultCase.map(caseInfos.indexOf).getOrElse(-1)},
         ${defaultCase.exists(_.transientCase)}
       ) {
-        def caseDependencies = ${mkNativeArray(tq"$GenCodecObj.OOOFieldsObjectCodec[_ <: $tpe]", caseInfos.map(_.depInstance))}
-        def oooDependencies = ${mkNativeArray(tq"$GenCodecCls[_]", oooParamNames.map(oooDependency))}
+        def caseDependencies = ${mkArray(tq"$GenCodecObj.OOOFieldsObjectCodec[_ <: $tpe]", caseInfos.map(_.depInstance))}
+        def oooDependencies = ${mkArray(tq"$GenCodecCls[_]", oooParamNames.map(oooDependency))}
       }
     """
   }