Merge pull request #1055 from novamon/i1039

I1039 Finishes executeFromSelfReg

Author: kushti

data/shared/src/main/scala/sigma/SigmaDataReflection.scala

@@ -645,6 +645,18 @@ object SigmaDataReflection {
     )
   )
 
+  registerClassEntry(classOf[DeserializeRegister[_]],
+    constructors = Array(
+      mkConstructor(Array(classOf[RegisterId], classOf[SType], classOf[SOption[_]])) { args =>
+        new DeserializeRegister[SType](
+          args(0).asInstanceOf[RegisterId],
+          args(1).asInstanceOf[SType],
+          args(2).asInstanceOf[Option[Value[SType]]]
+        )
+      }
+    )
+  )
+
   registerClassEntry(classOf[LongToByteArray],
     constructors = Array(
       mkConstructor(Array(classOf[Value[_]])) { args =>

data/shared/src/main/scala/sigma/ast/Operations.scala

@@ -190,7 +190,7 @@ object Operations {
   }
 
   object DeserializeRegisterInfo extends InfoObject {
-    private val func = predefinedOps.funcs("executeFromSelfReg")
+    private val func = predefinedOps.funcs("executeFromSelfRegWithDefault")
     val idArg: ArgInfo = func.argInfo("id")
     val defaultArg: ArgInfo = func.argInfo("default")
     val argInfos: Seq[ArgInfo] = Array(idArg, defaultArg)

data/shared/src/main/scala/sigma/ast/SigmaPredef.scala

@@ -2,12 +2,18 @@ package sigma.ast
 
 import org.ergoplatform.ErgoAddressEncoder.NetworkPrefix
 import org.ergoplatform.{ErgoAddressEncoder, P2PKAddress}
+import org.ergoplatform.ErgoBox.RegisterId
 import scorex.util.encode.{Base16, Base58, Base64}
+import sigma.data._
+import sigma.{Colls}
 import sigma.ast.SCollection.{SByteArray, SIntArray}
 import sigma.ast.SOption.SIntOption
 import sigma.ast.SigmaPropConstant
 import sigma.ast.syntax._
 import sigma.data.Nullable
+import sigma.data.RType.asType
+import sigma.Evaluation.stypeToRType
+import scala.reflect.ClassTag
 import sigma.exceptions.InvalidArguments
 import sigma.serialization.CoreByteWriter.ArgInfo
 import sigma.serialization.ValueSerializer
@@ -383,25 +389,63 @@ object SigmaPredef {
         Seq(ArgInfo("id", "identifier of the context variable")))
     )
 
-    val ExecuteFromSelfRegFunc = PredefinedFunc("executeFromSelfReg",
+    val ExecuteFromSelfRegWithDefaultFunc = PredefinedFunc("executeFromSelfRegWithDefault",
       Lambda(
         Seq(paramT),
-        Array("id" -> SByte, "default" -> SOption(tT)),
+        Array("id" -> SInt, "default" -> tT),
         tT, None
       ),
-      PredefFuncInfo(undefined),
+      PredefFuncInfo(
+        { case (Ident(_, SFunc(_, rtpe, _)), Seq(id: Constant[SNumericType]@unchecked, default)) =>
+          val idx: Int = SInt.downcast((id.value.asInstanceOf[AnyVal]))
+          if (idx < 0 || idx >= org.ergoplatform.ErgoBox.allRegisters.length) {
+            default.v
+          } else {
+            val r: RegisterId = org.ergoplatform.ErgoBox.registerByIndex(idx)
+            val d = Some(default.asValue[rtpe.type])
+            mkDeserializeRegister[rtpe.type](r, rtpe, d)
+          }
+        }),
       OperationInfo(DeserializeRegister,
         """Extracts SELF register as \lst{Coll[Byte]}, deserializes it to script
          | and then executes this script in the current context.
          | The original \lst{Coll[Byte]} of the script is available as \lst{SELF.getReg[Coll[Byte]](id)}.
          | Type parameter \lst{T} result type of the deserialized script.
          | Throws an exception if the actual script type doesn't conform to \lst{T}.
-         | Returns a result of the script execution in the current context
+         | Returns a result of the script execution in the current context or the default value
+         | provided when the specified register is unavailable
         """.stripMargin,
         Seq(ArgInfo("id", "identifier of the register"),
           ArgInfo("default", "optional default value, if register is not available")))
     )
 
+    val ExecuteFromSelfRegFunc = PredefinedFunc("executeFromSelfReg",
+      Lambda(
+        Seq(paramT),
+        Array("id" -> SInt),
+        tT, None
+      ),
+      PredefFuncInfo(
+        { case (Ident(_, SFunc(_, rtpe, _)), Seq(id: Constant[SNumericType]@unchecked)) =>
+          val idx: Int = SInt.downcast((id.value.asInstanceOf[AnyVal]))
+          if (idx < 0 || idx >= org.ergoplatform.ErgoBox.allRegisters.length) {
+            throw new InvalidArguments(s"Invalid register specified $id")
+          }
+
+          val r: RegisterId = org.ergoplatform.ErgoBox.registerByIndex(idx)
+          mkDeserializeRegister[rtpe.type](r, rtpe, None)
+        }),
+      OperationInfo(DeserializeRegister,
+        """Extracts SELF register as \lst{Coll[Byte]}, deserializes it to script
+          | and then executes this script in the current context.
+          | The original \lst{Coll[Byte]} of the script is available as \lst{SELF.getReg[Coll[Byte]](id)}.
+          | Type parameter \lst{T} result type of the deserialized script.
+          | Throws an exception if the actual script type doesn't conform to \lst{T}.
+          | Returns a result of the script execution in the current context
+        """.stripMargin,
+        Seq(ArgInfo("id", "identifier of the register")))
+    )
+
     val globalFuncs: Map[String, PredefinedFunc] = Seq(
       AllOfFunc,
       AnyOfFunc,
@@ -429,6 +473,7 @@ object SigmaPredef {
       AvlTreeFunc,
       SubstConstantsFunc,
       ExecuteFromVarFunc,
+      ExecuteFromSelfRegWithDefaultFunc,
       ExecuteFromSelfRegFunc
     ).map(f => f.name -> f).toMap
 

data/shared/src/main/scala/sigma/ast/transformers.scala

@@ -548,7 +548,7 @@ object DeserializeContext extends ValueCompanion {
 }
 
 /** Extract register of SELF box as Coll[Byte], deserialize it into Value and inline into executing script.
-  * NOTE: it only applicable to SELF box
+  * NOTE: it's only applicable to SELF box
   */
 case class DeserializeRegister[V <: SType](reg: RegisterId, tpe: V, default: Option[Value[V]] = None) extends Deserialize[V] {
   override def companion = DeserializeRegister

docs/LangSpec.md

@@ -1017,6 +1017,55 @@ def PK(input: String): SigmaProp
   */
 def deserialize[T](string: String): T
 
+/**  
+ *
+ * Extracts, deserializes and executes a script contained in the context variable specified
+ * by id. Returns the result of the script execution in the current context.
+ * Throws an exception if the result type of the execution doesn't conform to the return
+ * type specified.
+ * 
+ * @param id context variable holding the serialized script to execute
+ * @tparam T expected type of the variable and return type.
+ * @return result of the executed script
+ * @throws InvalidType exception when the result type of the execution value is 
+ *                     different from T. 
+ */
+def executeFromVar[T](id: Byte): T
+
+/**
+ * 
+ * Extracts, deserializes and executes a script contained in the SELF register 
+ * indicated by id. Returns the result of the script execution in the current context
+ * An exception is thrown if the result type of the execution doesn't conform to the
+ * return type specified and if an invalid register is specified.
+ * 
+ * @param id register id holding the serialized script to execute
+ * @tparam T expected type of the register and return type.
+ * @return result of the executed script or default value
+ * @throws InterpreterException when a script reduces to false
+ * @throws InvalidType exception when the result type of the execution value is 
+ *                     different from T.
+ */
+def executeFromSelfReg[T](id: Int): T
+
+/**
+ * 
+ * Extracts, deserializes and executes a script contained in the SELF register 
+ * indicated by id. Returns the result of the script execution in the current context
+ * or default value, if the register is unavailable. An exception is thrown if the result 
+ * type of the execution doesn't conform to the return type specified and if an invalid 
+ * register is specified.
+ * 
+ * @param id register id holding the serialized script to execute
+ * @param default value returned if the register is unavailable
+ * @tparam T expected type of the register and return type.
+ * @return result of the executed script or default value
+ * @throws InterpreterException when a script reduces to false
+ * @throws InvalidType exception when the result type of the execution value is 
+ *                     different from T.
+ */
+def executeFromSelfRegWithDefault[T](id: Int, default: T): T
+
 /**
   * Transforms serialized bytes of ErgoTree with segregated constants by
   * replacing constants at given positions with new values. This operation allow

sc/shared/src/main/scala/sigma/compiler/ir/Base.scala

@@ -2,7 +2,7 @@ package sigma.compiler.ir
 
 import debox.{cfor, Buffer => DBuffer}
 import sigma.compiler.ir.core.MutableLazy
-import sigma.ast.{DeserializeContext, SType}
+import sigma.ast.{DeserializeContext, DeserializeRegister, SType}
 import sigma.data.{AVHashMap, Nullable, RType}
 import sigma.data.OverloadHack.Overloaded1
 import sigma.reflection.RConstructor
@@ -211,6 +211,13 @@ abstract class Base { thisIR: IRContext =>
     override def resultType: Elem[V#WrappedType] = e
   }
 
+  /**
+   * Def done in order to carry on DeserializeRegister through stages of compilation intact
+   */
+  case class DeserializeRegisterDef[V <: SType](d: DeserializeRegister[V], e: Elem[V#WrappedType]) extends Def[V#WrappedType] {
+    override def resultType: Elem[V#WrappedType] = e
+  }
+
   /** Base class for virtualized instances of type companions.
     * Each virtualized entity type (trait or class) may have virtualized companion class. */
   abstract class CompanionDef[T] extends Def[T] {

sc/shared/src/main/scala/sigma/compiler/ir/GraphBuilding.scala

@@ -17,6 +17,7 @@ import sigma.{SigmaException, ast}
 import sigmastate.interpreter.Interpreter.ScriptEnv
 
 import scala.collection.mutable.ArrayBuffer
+import scala.language.{existentials,implicitConversions}
 
 /** Perform translation of typed expression given by [[Value]] to a graph in IRContext.
   * Which be than be translated to [[ErgoTree]] by using [[TreeBuilding]].
@@ -553,6 +554,10 @@ trait GraphBuilding extends Base with DefRewriting { IR: IRContext =>
         val e = stypeToElem(d.tpe)
         DeserializeContextDef(d, e)
 
+      case d: DeserializeRegister[T] =>
+        val e = stypeToElem(d.tpe)
+        DeserializeRegisterDef[T](d, e)
+
       case ValUse(valId, _) =>
         env.getOrElse(valId, !!!(s"ValUse $valId not found in environment $env"))
 

sc/shared/src/main/scala/sigma/compiler/ir/TreeBuilding.scala

@@ -192,6 +192,9 @@ trait TreeBuilding extends Base { IR: IRContext =>
       case Def(DeserializeContextDef(d, _)) =>
         d
 
+      case Def(DeserializeRegisterDef(d, _)) =>
+        d
+
       case Def(IsContextProperty(v)) => v
       case s if s == sigmaDslBuilder => Global
 

sc/shared/src/test/scala/sigmastate/lang/SigmaTyperTest.scala

@@ -563,6 +563,14 @@ class SigmaTyperTest extends AnyPropSpec
     typecheck(env, "executeFromVar[Boolean](1)") shouldBe SBoolean
   }
 
+  property("executeFromSelfRegWithDefault") {
+    typecheck(env, "executeFromSelfRegWithDefault[Boolean](4, getVar[Boolean](1).get)") shouldBe SBoolean
+
+    an[TyperException] should be thrownBy {
+      typecheck(env, "executeFromSelfRegWithDefault[Boolean](4, getVar[Int](1).get)")
+    }
+  }
+
   property("LogicalNot") {
     typecheck(env, "!true") shouldBe SBoolean
     typefail(env, "!getVar[SigmaProp](1).get", 1, 2)