Implement missing ops and predefined functions for 2.0

src/main/scala/sigmastate/serialization/MethodCallSerializer.scala

@@ -3,7 +3,7 @@ package sigmastate.serialization
 import sigmastate.Values._
 import sigmastate._
 import sigmastate.lang.SigmaTyper.STypeSubst
-import sigmastate.lang.Terms.MethodCall
+import sigmastate.lang.Terms.{MethodCall, STypeParam}
 import sigmastate.utils.{SigmaByteReader, SigmaByteWriter}
 
 case class MethodCallSerializer(opCode: Byte, cons: (Value[SType], SMethod, IndexedSeq[Value[SType]], STypeSubst) => Value[SType])
@@ -17,25 +17,38 @@ case class MethodCallSerializer(opCode: Byte, cons: (Value[SType], SMethod, Inde
       assert(mc.args.nonEmpty)
       w.putValues(mc.args)
     }
-    w.putUByte(mc.typeSubst.size)
-    mc.typeSubst.foreach { case (typeIdent, tpe) => w.putType(typeIdent).putType(tpe) }
+    mc.method.stype match {
+      case genType: SGenericType =>
+        w.putUByte(mc.typeSubst.size)
+        mc.typeSubst.foreach { case (ti, tpe) =>
+          val tpIndex = genType.substitutedTypeParams.indexOf(STypeParam(ti))
+          w.putUByte(tpIndex)
+            .putType(tpe)
+        }
+      case _ => w.putUByte(0)
+    }
   }
 
   override def parse(r: SigmaByteReader): Value[SType] = {
     val typeId = r.getByte()
     val methodId = r.getByte()
     val obj = r.getValue()
-    val args = if (opCode == OpCodes.MethodCallCode) {
-      r.getValues()
-    }
-    else IndexedSeq()
+    val args = if (opCode == OpCodes.MethodCallCode) r.getValues() else IndexedSeq()
     val method = MethodCall.fromIds(typeId, methodId)
-    val typeSubstSize = r.getUByte()
-    val xs = new Array[(STypeIdent, SType)](typeSubstSize)
-    for (i <- 0 until typeSubstSize) {
-      xs(i) = (r.getType().asInstanceOf[STypeIdent], r.getType())
+    val typeSubst: STypeSubst = method.stype match {
+      case genType: SGenericType =>
+        val typeSubstSize = r.getUByte()
+        val xs = new Array[(STypeIdent, SType)](typeSubstSize)
+        for (i <- 0 until typeSubstSize) {
+          val tpIndex = r.getUByte()
+          val ti = genType.substitutedTypeParams.apply(tpIndex).ident
+          xs(i) = (ti, r.getType())
+        }
+        xs.toMap
+      case _ =>
+        r.getUByte() // read 0
+        Map()
     }
-    val typeSubst = xs.toMap
     cons(obj, method, args, typeSubst)
   }
 }

src/main/scala/sigmastate/types.scala

@@ -232,7 +232,16 @@ trait SProduct extends SType {
   * e.g. Array[T], Option[T], etc.)*/
 trait SGenericType {
   def typeParams: Seq[STypeParam]
-  def tparamSubst: Map[String, SType]
+  def tparamSubst: Map[STypeIdent, SType]
+
+  lazy val substitutedTypeParams: Seq[STypeParam] =
+    typeParams.map { tp =>
+      tparamSubst.getOrElse(tp.ident, tp.ident) match {
+        case v: STypeIdent => STypeParam(v)
+        case _ => tp
+      }
+    }
+
 }
 
 /** Method info including name, arg type and result type.
@@ -565,7 +574,8 @@ case object SUnit extends SPrimType {
 
 /** Type description of optional values. Instances of `Option`
   *  are either constructed by `Some` or by `None` constructors. */
-case class SOption[ElemType <: SType](elemType: ElemType) extends SProduct {
+case class SOption[ElemType <: SType](elemType: ElemType) extends SProduct with SGenericType {
+  import SOption._
   override type WrappedType = Option[ElemType#WrappedType]
   override val typeCode: TypeCode = SOption.OptionTypeCode
   override def dataSize(v: SType#WrappedType) = {
@@ -576,6 +586,8 @@ case class SOption[ElemType <: SType](elemType: ElemType) extends SProduct {
   def ancestors = Nil
   override def methods: Seq[SMethod] = SOption.methods
   override def toString = s"Option[$elemType]"
+  val typeParams: Seq[STypeParam] = Seq(STypeParam(tT))
+  def tparamSubst: Map[STypeIdent, SType] = Map(tT -> elemType)
 }
 
 object SOption extends STypeCompanion {
@@ -662,8 +674,8 @@ case class SCollectionType[T <: SType](elemType: T) extends SCollection[T] {
         arr.map(x => elemType.dataSize(x)).sum
     res
   }
-  def typeParams = SCollectionType.typeParams
-  def tparamSubst = Map(tIV.name -> elemType)
+  def typeParams: Seq[STypeParam] = SCollectionType.typeParams
+  def tparamSubst: Map[STypeIdent, SType] = Map(tIV -> elemType)
   override def methods = SCollection.methods
   override def toString = s"Coll[$elemType]"
 }
@@ -921,10 +933,12 @@ case class SFunc(tDom: IndexedSeq[SType],  tRange: SType, tpeParams: Seq[STypePa
   }
   override def dataSize(v: SType#WrappedType) = 8L
   import SFunc._
-  val typeParams: Seq[STypeParam] = (tDom.zipWithIndex.map { case (t, i) => STypeParam(tD.name + (i + 1)) }) :+ STypeParam(tR.name)
-  val tparamSubst = typeParams.zip(tDom).map { case (p, t) => p.ident.name -> t }.toMap + (tR.name -> tRange)
+  val typeParams: Seq[STypeParam] = tpeParams
+  val tparamSubst: Map[STypeIdent, SType] = Map() // defined in MethodCall.typeSubst
 
   def getGenericType: SFunc = {
+    val typeParams: Seq[STypeParam] = tDom.zipWithIndex
+      .map { case (t, i) => STypeParam(tD.name + (i + 1)) } :+ STypeParam(tR.name)
     val ts = typeParams.map(_.ident)
     SFunc(ts.init.toIndexedSeq, ts.last, Nil)
   }

src/test/scala/sigmastate/serialization/MethodCallSerializerSpecification.scala

@@ -4,7 +4,7 @@ import org.ergoplatform.Outputs
 import sigmastate.Values.{FuncValue, ValUse}
 import sigmastate.lang.Terms.MethodCall
 import sigmastate.utxo.ExtractScriptBytes
-import sigmastate.{SBox, SByte, SCollection}
+import sigmastate._
 
 class MethodCallSerializerSpecification extends SerializationSpecification {
 
@@ -17,4 +17,12 @@ class MethodCallSerializerSpecification extends SerializationSpecification {
     roundTripTest(expr)
   }
 
+  property("MethodCall deserialization round trip (non-generic method)") {
+    val expr = MethodCall(Outputs,
+      SMethod(SCollection, "size", SInt, 1),
+      Vector(),
+      Map()
+    )
+    roundTripTest(expr)
+  }
 }