fix SOption.method to have generic types (don't substitute for SOptio…

…n.elemType on the fly);
ergoplatform · Feb 21, 2019 · 61b06e1 · 61b06e1
1 parent 4029d49
commit 61b06e1
Show file tree

Hide file tree

Showing 6 changed files with 34 additions and 25 deletions.
diff --git a/src/main/scala/sigmastate/lang/SigmaTyper.scala b/src/main/scala/sigmastate/lang/SigmaTyper.scala
@@ -80,17 +80,24 @@ class SigmaTyper(val builder: SigmaBuilder, predefFuncRegistry: PredefinedFuncRe
       val newObj = assignType(env, obj)
       newObj.tpe match {
         case s: SProduct =>
-          val iField = s.methodIndex(n)
-          val tRes = if (iField != -1) {
-            s.methods(iField).stype
-          } else
-            throw new MethodNotFound(s"Cannot find method '$n' in in the object $obj of Product type with methods ${s.methods}", obj.sourceContext.toOption)
           s.method(n) match {
-            case Some(method) if method.irBuilder.isDefined && !method.stype.isFunc =>
-              method.irBuilder.flatMap(_.lift(builder, newObj, method, IndexedSeq(), emptySubst))
+            case Some(method @ SMethod(SOption, _, stype, _, irBuilder)) if !stype.isFunc =>
+              val optTypeSubst = Map(SOption.tT -> newObj.tpe.asOption.elemType)
+              val typeSubst = if (applySubst(stype, optTypeSubst) == stype) emptySubst else optTypeSubst
+              if (irBuilder.isDefined)
+                irBuilder.flatMap(_.lift(builder, newObj, method, IndexedSeq(), typeSubst))
+                  .getOrElse(mkMethodCall(newObj, method, IndexedSeq(), typeSubst))
+              else
+                mkSelect(newObj, n, Some(applySubst(stype, typeSubst)))
+
+            case Some(method @ SMethod(_, _, stype, _, irBuilder)) if irBuilder.isDefined && !stype.isFunc =>
+              irBuilder.flatMap(_.lift(builder, newObj, method, IndexedSeq(), emptySubst))
                 .getOrElse(mkMethodCall(newObj, method, IndexedSeq(), emptySubst))
-            case _ =>
-              mkSelect(newObj, n, Some(tRes))
+
+            case Some(method) =>
+              mkSelect(newObj, n, Some(method.stype))
+            case None =>
+              throw new MethodNotFound(s"Cannot find method '$n' in in the object $obj of Product type with methods ${s.methods}", obj.sourceContext.toOption)
           }
         case t =>
           error(s"Cannot get field '$n' in in the object $obj of non-product type $t", sel.sourceContext)

diff --git a/src/main/scala/sigmastate/lang/Terms.scala b/src/main/scala/sigmastate/lang/Terms.scala
@@ -141,7 +141,7 @@ object Terms {
     override def opType: SFunc = SFunc(obj.tpe +: args.map(_.tpe), tpe)
     override val tpe: SType = method.stype match {
       case f: SFunc => f.tRange.withSubstTypes(typeSubst)
-      case t => t
+      case t => t.withSubstTypes(typeSubst)
     }
   }
   object MethodCall {

diff --git a/src/main/scala/sigmastate/types.scala b/src/main/scala/sigmastate/types.scala
@@ -111,7 +111,7 @@ object SType {
     * NOTE: in the current implementation only monomorphic methods are supported (without type parameters)*/
   val types: Map[Byte, STypeCompanion] = Seq(
     SNumericType, SString, STuple, SGroupElement, SSigmaProp, SContext,
-    SAvlTree, SBox, SCollection
+    SAvlTree, SBox, SCollection, SBigInt, SOption
   ).map { t => (t.typeId, t) }.toMap
 
   implicit class STypeOps(val tpe: SType) extends AnyVal {
@@ -573,12 +573,7 @@ case class SOption[ElemType <: SType](elemType: ElemType) extends SProduct {
   }
   override def isConstantSize = elemType.isConstantSize
   def ancestors = Nil
-  override lazy val methods: Seq[SMethod] = {
-    val subst = Map(SOption.tT -> elemType)
-    SOption.methods.map { method =>
-      method.copy(stype = SigmaTyper.applySubst(method.stype, subst))
-    }
-  }
+  override def methods: Seq[SMethod] = SOption.methods
   override def toString = s"Option[$elemType]"
 }
 

diff --git a/src/test/scala/sigmastate/FailingToProveSpec.scala b/src/test/scala/sigmastate/FailingToProveSpec.scala
@@ -52,7 +52,7 @@ class FailingToProveSpec extends SigmaTestingCommons {
     val verifier = new ErgoLikeTestInterpreter()
 
     val env = Map.empty[String, Any]
-    val compiledScript = compile(env,
+    val compiledScript = compileWithCosting(env,
       s"""
          | {
          |

diff --git a/src/test/scala/sigmastate/helpers/SigmaTestingCommons.scala b/src/test/scala/sigmastate/helpers/SigmaTestingCommons.scala
@@ -47,7 +47,6 @@ trait SigmaTestingCommons extends PropSpec
 
   def compile(env: ScriptEnv, code: String): Value[SType] = {
     val tree = compiler.compile(env, code)
-    checkSerializationRoundTrip(tree)
     tree
   }
 

diff --git a/src/test/scala/sigmastate/lang/SigmaCompilerTest.scala b/src/test/scala/sigmastate/lang/SigmaCompilerTest.scala
@@ -24,10 +24,18 @@ class SigmaCompilerTest extends SigmaTestingCommons with LangTests with ValueGen
   private def comp(env: ScriptEnv, x: String): Value[SType] = compileWithCosting(env, x)
   private def comp(x: String): Value[SType] = compileWithCosting(env, x)
   private def compWOCosting(x: String): Value[SType] = compile(env, x)
-  private def compWOCosting(env: ScriptEnv, x: String): Value[SType] = compile(env, x)
 
   private def testMissingCosting(script: String, expected: SValue): Unit = {
-    compWOCosting(script) shouldBe expected
+    val tree = compWOCosting(script)
+    tree shouldBe expected
+    checkSerializationRoundTrip(tree)
+    // when implemented in coster this should be changed to a positive expectation
+    an [CosterException] should be thrownBy comp(env, script)
+  }
+
+  private def testMissingCostingWOSerialization(script: String, expected: SValue): Unit = {
+    val tree = compWOCosting(script)
+    tree shouldBe expected
     // when implemented in coster this should be changed to a positive expectation
     an [CosterException] should be thrownBy comp(env, script)
   }
@@ -312,7 +320,7 @@ class SigmaCompilerTest extends SigmaTestingCommons with LangTests with ValueGen
   }
 
   property("SOption.flatMap") {
-    testMissingCosting("getVar[Int](1).flatMap({(i: Int) => getVar[Int](2)})",
+    testMissingCostingWOSerialization("getVar[Int](1).flatMap({(i: Int) => getVar[Int](2)})",
       mkMethodCall(GetVarInt(1),
         SOption.FlatMapMethod,
         IndexedSeq(Terms.Lambda(
@@ -420,7 +428,7 @@ class SigmaCompilerTest extends SigmaTestingCommons with LangTests with ValueGen
   }
 
   property("SCollection.prefixLength") {
-    testMissingCosting("OUTPUTS.prefixLength({ (out: Box) => out.value >= 1L })",
+    testMissingCostingWOSerialization("OUTPUTS.prefixLength({ (out: Box) => out.value >= 1L })",
       mkMethodCall(Outputs,
         SCollection.PrefixLengthMethod,
         Vector(
@@ -453,7 +461,7 @@ class SigmaCompilerTest extends SigmaTestingCommons with LangTests with ValueGen
   }
 
   property("SCollection.find") {
-    testMissingCosting("OUTPUTS.find({ (out: Box) => out.value >= 1L })",
+    testMissingCostingWOSerialization("OUTPUTS.find({ (out: Box) => out.value >= 1L })",
       mkMethodCall(Outputs,
         SCollection.FindMethod,
         Vector(
@@ -518,7 +526,7 @@ class SigmaCompilerTest extends SigmaTestingCommons with LangTests with ValueGen
   }
 
   property("SCollection.mapReduce") {
-    testMissingCosting(
+    testMissingCostingWOSerialization(
       "Coll(1, 2).mapReduce({ (i: Int) => (i > 0, i.toLong) }, { (tl: (Long, Long)) => tl._1 + tl._2 })",
       mkMethodCall(
         ConcreteCollection(IntConstant(1), IntConstant(2)),