V4.x pretty ergo tree

.github/workflows/ci.yml

@@ -16,6 +16,8 @@ env:
 jobs:
   build:
     name: Test and publish a snapshot
+    env:
+      HAS_SECRETS: ${{ secrets.SONATYPE_PASSWORD != '' }}
     strategy:
       matrix:
         os: [ubuntu-latest]

build.sbt

@@ -59,6 +59,7 @@ val kiama              = "org.bitbucket.inkytonik.kiama" %% "kiama" % "2.1.0"
 val fastparse          = "com.lihaoyi" %% "fastparse" % "1.0.0"
 val commonsIo          = "commons-io" % "commons-io" % "2.5"
 val commonsMath3       = "org.apache.commons" % "commons-math3" % "3.2"
+val paiges             = "org.typelevel" %% "paiges-core" % "0.3.0"
 
 val testingDependencies = Seq(
   "org.scalatest" %% "scalatest" % "3.0.5" % "test",
@@ -209,7 +210,7 @@ lazy val sigmastate = (project in file("sigmastate"))
   .dependsOn(sigmaimpl % allConfigDependency, sigmalibrary % allConfigDependency)
   .settings(libraryDefSettings)
   .settings(libraryDependencies ++= Seq(
-    scorexUtil, kiama, fastparse, commonsMath3,
+    scorexUtil, kiama, fastparse, commonsMath3, paiges,
     if (scalaVersion.value == scala211) circeCore211 else circeCore,
     if (scalaVersion.value == scala211) circeGeneric211 else circeGeneric,
     if (scalaVersion.value == scala211) circeParser211 else circeParser

core/src/main/scala/scalan/Base.scala

@@ -709,7 +709,14 @@ abstract class Base { scalan: Scalan =>
       cfor(0)(_ < delta, _ + 1) { _ => tab.append(null) }
       val sym = if (s == null) new SingleRef(d) else s
       tab += sym
-      assert(tab.length == id + 1)
+      assert(tab.length == id + 1,
+        s"""tab.length == id + 1:
+          |tab.length = ${tab.length}
+          |id = $id
+          |s = $s
+          |d = $d
+          |sym = $sym
+          |""".stripMargin)
       sym
     }
   }
@@ -781,7 +788,6 @@ abstract class Base { scalan: Scalan =>
     if (sym == null) {
       sym = createDefinition(optScope, newSym, d)
     }
-//    assert(te.rhs == d, s"${if (te !) "Found" else "Created"} unequal definition ${te.rhs} with symbol ${te.sym.toStringWithType} for $d")
     sym
   }
 
@@ -792,15 +798,36 @@ abstract class Base { scalan: Scalan =>
     * @return  reference to `d` (which is `s`)
     */
   protected def createDefinition[T](optScope: Nullable[ThunkScope], s: Ref[T], d: Def[T]): Ref[T] = {
-    assert(_symbolTable(d.nodeId).node.nodeId == d.nodeId)
-    assert(s.node eq d, s"Inconsistent Sym -> Def pair $s -> $d")
-    optScope match {
-      case Nullable(scope) =>
-        scope += s
-      case _ =>
-        _globalDefs.put(d, d)
+    try {
+      val nodeId = d.nodeId
+      val tableSym = _symbolTable(nodeId)
+      assert(tableSym.node.nodeId == nodeId)
+      assert(s.node eq d, s"Inconsistent Sym -> Def pair $s -> $d")
+      optScope match {
+        case Nullable(scope) =>
+          scope += s
+        case _ =>
+          _globalDefs.put(d, d)
+      }
+      s
+    } catch { case t: Throwable =>
+      val msg = new mutable.StringBuilder(
+        s"""optScope = $optScope
+        |s = $s
+        |d = $d""".stripMargin)
+      if (d != null) {
+        msg ++= s"\nd.nodeId = ${d.nodeId}"
+        val tableSym = _symbolTable(d.nodeId)
+        msg ++= s"\n_symbolTable(d.nodeId) = $tableSym"
+        if (tableSym != null) {
+          msg ++= s"\ntableSym.node = ${tableSym.node}"
+          if (tableSym.node != null) {
+            msg ++= s"\ntableSym.node.nodeId = ${tableSym.node.nodeId}"
+          }
+        }
+      }
+      throw new RuntimeException(msg.result(), t)
     }
-    s
   }
 
   /**

library-impl/src/main/scala/special/collection/Helpers.scala

@@ -27,7 +27,11 @@ object Helpers {
     var nValues = 0
     while (i < arr.length) {
       val (key, value) = m(arr(i))
-      val pos = keyPositions.getOrDefault(key, 0)
+      val pos = {
+        val p: Integer = keyPositions.get(key)
+        if (p == null) 0 else p.intValue()
+      }
+
       if (pos == 0) {
         keyPositions.put(key, nValues + 1)
         keys += key

sigmastate/src/main/scala/sigmastate/Values.scala

@@ -72,6 +72,12 @@ object Values {
 
     def opName: String = this.getClass.getSimpleName
 
+    def toSigmaProp: SigmaPropValue = this match {
+      case b if b.tpe == SBoolean => BoolToSigmaProp(this.asBoolValue)
+      case p if p.tpe == SSigmaProp => p.asSigmaProp
+      case _ => sys.error(s"Expected SBoolean or SSigmaProp typed value, but was: $this")
+    }
+
     /** Parser has some source information like line,column in the text. We need to keep it up until RuntimeCosting.
     * The way to do this is to add Nullable property to every Value. Since Parser is always using SigmaBuilder
     * to create nodes,
@@ -279,7 +285,7 @@ object Values {
     override def costKind: PerItemCost
   }
 
-  abstract class EvaluatedValue[+S <: SType] extends Value[S] {
+  sealed abstract class EvaluatedValue[+S <: SType] extends Value[S] {
     val value: S#WrappedType
     def opType: SFunc = {
       val resType = tpe match {
@@ -680,6 +686,7 @@ object Values {
   }
 
 
+  // TODO: Consider moving to trees.scala
   trait NotReadyValueGroupElement extends NotReadyValue[SGroupElement.type] {
     override def tpe = SGroupElement
   }
@@ -707,6 +714,7 @@ object Values {
     override def costKind: FixedCost = Constant.costKind
   }
 
+  // TODO: Consider moving to trees.scala and make it sealed
   trait NotReadyValueBoolean extends NotReadyValue[SBoolean.type] {
     override def tpe = SBoolean
   }
@@ -968,6 +976,7 @@ object Values {
     override def costKind = ConcreteCollection.costKind
   }
 
+  // TODO: Make sense to move to ErgoLikeContext?
   trait LazyCollection[V <: SType] extends NotReadyValue[SCollection[V]]
 
   implicit class CollectionOps[T <: SType](val coll: Value[SCollection[T]]) extends AnyVal {
@@ -1007,14 +1016,6 @@ object Values {
     }
   }
 
-  implicit class BoolValueOps(val b: BoolValue) extends AnyVal {
-    def toSigmaProp: SigmaPropValue = b match {
-      case b if b.tpe == SBoolean => BoolToSigmaProp(b)
-      case p if p.tpe == SSigmaProp => p.asSigmaProp
-      case _ => sys.error(s"Expected SBoolean or SSigmaProp typed value, but was: $b")
-    }
-  }
-
   sealed trait BlockItem extends NotReadyValue[SType] {
     def id: Int
     def rhs: SValue

sigmastate/src/main/scala/sigmastate/eval/IRContext.scala

@@ -1,19 +1,23 @@
 package sigmastate.eval
 
-import java.lang.{Math => JMath}
 import sigmastate.SType
-import sigmastate.Values.{Value, SValue}
+import sigmastate.Values.{SValue, Value}
 import sigmastate.interpreter.Interpreter.ScriptEnv
 import sigmastate.lang.TransformingSigmaBuilder
 import sigmastate.lang.exceptions.CostLimitException
+import sigmastate.utils.Helpers
 import sigmastate.utxo.CostTable
 
+import java.util.concurrent.locks.ReentrantLock
 import scala.util.Try
 
 trait IRContext extends Evaluation with TreeBuilding {
 
   override val builder = TransformingSigmaBuilder
 
+  /** Can be used to synchronize access to this IR object from multiple threads. */
+  val lock = new ReentrantLock()
+
   /** Pass configuration which is used to turn-off constant propagation.
     * @see `beginPass(noCostPropagationPass)`  */
   lazy val noConstPropagationPass = new DefaultPass(
@@ -125,9 +129,12 @@ trait IRContext extends Evaluation with TreeBuilding {
     */
   def checkCostWithContext(ctx: SContext,
                 costF: Ref[((Context, (Int, Size[Context]))) => Int], maxCost: Long, initCost: Long): Try[Int] = Try {
-    val costFun = compile[(SContext, (Int, SSize[SContext])), Int, (Context, (Int, Size[Context])), Int](
-                    getDataEnv, costF, Some(maxCost))
-    val (estimatedCost, accCost) = costFun((ctx, (0, Sized.sizeOf(ctx))))
+
+    val (estimatedCost, accCost) = Helpers.withReentrantLock(lock) { // protect mutable access to this IR
+      val costFun = compile[(SContext, (Int, SSize[SContext])), Int, (Context, (Int, Size[Context])), Int](
+        getDataEnv, costF, Some(maxCost))
+      costFun((ctx, (0, Sized.sizeOf(ctx))))
+    }
 
     if (debugModeSanityChecks) {
       if (estimatedCost != accCost)

sigmastate/src/main/scala/sigmastate/eval/RuntimeCosting.scala

@@ -799,6 +799,7 @@ trait RuntimeCosting extends CostingRules { IR: IRContext =>
   def isCostingProcess: Boolean = funUnderCosting != null
 
   def stypeToElem[T <: SType](t: T): Elem[T#WrappedType] = (t match {
+    case SUnit => UnitElement
     case SBoolean => BooleanElement
     case SByte => ByteElement
     case SShort => ShortElement
@@ -823,6 +824,7 @@ trait RuntimeCosting extends CostingRules { IR: IRContext =>
   }).asInstanceOf[Elem[T#WrappedType]]
 
   def elemToSType[T](e: Elem[T]): SType = e match {
+    case UnitElement => SUnit
     case BooleanElement => SBoolean
     case ByteElement => SByte
     case ShortElement => SShort

sigmastate/src/main/scala/sigmastate/interpreter/PrecompiledScriptProcessor.scala

@@ -2,17 +2,17 @@ package sigmastate.interpreter
 
 import java.util.concurrent.ExecutionException
 import java.util.concurrent.atomic.AtomicInteger
-
-import com.google.common.cache.{CacheBuilder, RemovalNotification, RemovalListener, LoadingCache, CacheLoader, CacheStats}
+import com.google.common.cache.{CacheBuilder, CacheLoader, CacheStats, LoadingCache, RemovalListener, RemovalNotification}
 import org.ergoplatform.settings.ErgoAlgos
 import org.ergoplatform.validation.SigmaValidationSettings
-import org.ergoplatform.validation.ValidationRules.{CheckCostFunc, CheckCalcFunc, trySoftForkable}
+import org.ergoplatform.validation.ValidationRules.{CheckCalcFunc, CheckCostFunc, trySoftForkable}
 import scalan.{AVHashMap, Nullable}
 import sigmastate.Values
 import sigmastate.Values.ErgoTree
-import sigmastate.eval.{RuntimeIRContext, IRContext}
+import sigmastate.eval.{IRContext, RuntimeIRContext}
 import sigmastate.interpreter.Interpreter.{ReductionResult, WhenSoftForkReductionResult}
 import sigmastate.serialization.ErgoTreeSerializer
+import sigmastate.utils.Helpers
 import sigmastate.utils.Helpers._
 import spire.syntax.all.cfor
 
@@ -84,9 +84,11 @@ case class PrecompiledScriptReducer(scriptBytes: Seq[Byte])(implicit val IR: IRC
       val estimatedCost = IR.checkCostWithContext(costingCtx, costF, maxCost, initCost).getOrThrow
 
       // check calc
-      val calcF = costingRes.calcF
       val calcCtx = context.toSigmaContext(isCost = false)
-      val res = Interpreter.calcResult(IR)(calcCtx, calcF)
+      val res = Helpers.withReentrantLock(IR.lock) { // protecting mutable access to IR instance
+        val calcF = costingRes.calcF
+        Interpreter.calcResult(IR)(calcCtx, calcF)
+      }
       ReductionResult(SigmaDsl.toSigmaBoolean(res), estimatedCost)
     }
   }

sigmastate/src/main/scala/sigmastate/trees.scala

@@ -232,7 +232,7 @@ object CreateProveDHTuple extends ValueCompanion {
   override val costKind = FixedCost(20)
 }
 
-trait SigmaTransformer[IV <: SigmaPropValue, OV <: SigmaPropValue] extends SigmaPropValue {
+sealed trait SigmaTransformer[IV <: SigmaPropValue, OV <: SigmaPropValue] extends SigmaPropValue {
   val items: Seq[IV]
 }
 trait SigmaTransformerCompanion extends ValueCompanion {

sigmastate/src/main/scala/sigmastate/utils/Helpers.scala

@@ -1,16 +1,16 @@
 package sigmastate.utils
 
-import java.util
-
 import io.circe.Decoder
 import org.ergoplatform.settings.ErgoAlgos
 import sigmastate.eval.{Colls, SigmaDsl}
 import sigmastate.interpreter.CryptoConstants.EcPointType
 import special.collection.Coll
 import special.sigma.GroupElement
 
+import java.util
+import java.util.concurrent.locks.Lock
 import scala.reflect.ClassTag
-import scala.util.{Failure, Try, Either, Success, Right}
+import scala.util.{Either, Failure, Right, Success, Try}
 
 object Helpers {
   def xor(ba1: Array[Byte], ba2: Array[Byte]): Array[Byte] = ba1.zip(ba2).map(t => (t._1 ^ t._2).toByte)
@@ -158,6 +158,27 @@ object Helpers {
     val bytes = ErgoAlgos.decodeUnsafe(base16String)
     Colls.fromArray(bytes)
   }
+
+  /**
+    * Executes the given block with a reentrant mutual exclusion Lock with the same basic
+    * behavior and semantics as the implicit monitor lock accessed using synchronized
+    * methods and statements in Java.
+    *
+    * Note, using this method has an advantage of having this method in a stack trace in case of
+    * an exception in the block.
+    * @param l lock object which should be acquired by the current thread before block can start executing
+    * @param block block of code which will be executed retaining the lock
+    * @return the value produced by the block
+    */
+  def withReentrantLock[A](l: Lock)(block: => A): A = {
+    l.lock()
+    val res = try
+      block
+    finally {
+      l.unlock()
+    }
+    res
+  }
 }
 
 object Overloading {

sigmastate/src/main/scala/sigmastate/utxo/transformers.scala

@@ -136,7 +136,7 @@ object Filter extends ValueCompanion {
 }
 
 /** Transforms a collection of values to a boolean (see [[Exists]], [[ForAll]]). */
-trait BooleanTransformer[IV <: SType] extends Transformer[SCollection[IV], SBoolean.type] {
+sealed trait BooleanTransformer[IV <: SType] extends Transformer[SCollection[IV], SBoolean.type] {
   override val input: Value[SCollection[IV]]
   val condition: Value[SFunc]
   override def tpe = SBoolean
@@ -434,6 +434,7 @@ object ExtractBytes extends SimpleTransformerCompanion {
   override def argInfos: Seq[ArgInfo] = ExtractBytesInfo.argInfos
 }
 
+// TODO: Rename to WithoutRef to be consistent with script
 /** Extracts serialized bytes of this box's content, excluding transactionId and index of output. */
 case class ExtractBytesWithNoRef(input: Value[SBox.type]) extends Extract[SByteArray] with NotReadyValueByteArray {
   override def companion = ExtractBytesWithNoRef
@@ -523,7 +524,7 @@ object ExtractCreationInfo extends SimpleTransformerCompanion {
   val OpType = SFunc(SBox, ResultType)
 }
 
-trait Deserialize[V <: SType] extends NotReadyValue[V]
+sealed trait Deserialize[V <: SType] extends NotReadyValue[V]
 
 /** Extracts context variable as Coll[Byte], deserializes it to script and then executes this script in the current context.
   * The original `Coll[Byte]` of the script is available as `getVar[Coll[Byte]](id)`