minimize-modules: addressed review comments

core/shared/src/main/scala/sigma/kiama/rewriting/Rewriter.scala

@@ -12,7 +12,6 @@ package sigma.kiama
 package rewriting
 
 import sigma.reflection.{Platform, RClass, RConstructor}
-//import sigma.kiama.==>
 
 /**
   * Strategy-based term rewriting in the style of Stratego (http://strategoxt.org/).

core/shared/src/main/scala/sigma/package.scala

@@ -45,6 +45,8 @@ package object sigma {
 
   /** Allows implicit resolution to find appropriate instance of ClassTag in
     * the scope where RType is implicitly available.
+    * NOTE, this implicit is shadowed internally in some places (search for `def rtypeToClassTag`),
+    * hence renaming it requires changing of the shadowing methods.
     */
   implicit def rtypeToClassTag[A](implicit t: RType[A]): ClassTag[A] = t.classTag
 

interpreter/shared/src/main/scala/sigmastate/eval/CostingDataContext.scala

@@ -1,35 +1,33 @@
 package sigmastate.eval
 
 import debox.cfor
-import org.ergoplatform.validation.{SigmaValidationSettings, ValidationRules}
-import org.ergoplatform.{ErgoBox, SigmaConstants}
+import org.ergoplatform.validation.{ValidationRules, SigmaValidationSettings}
+import org.ergoplatform.{SigmaConstants, ErgoBox}
 import sigma.data.OverloadHack.Overloaded1
-import sigma.data.{CollOverArrayBuilder, RType}
+import sigma.data.RType
 import sigma.util.Extensions.BigIntegerOps
 import scorex.crypto.authds.avltree.batch._
-import scorex.crypto.authds.{ADDigest, ADKey, ADValue, SerializedAdProof}
+import scorex.crypto.authds.{SerializedAdProof, ADDigest, ADValue, ADKey}
 import scorex.crypto.hash.{Blake2b256, Digest32, Sha256}
-import scorex.utils.{Ints, Longs}
-import sigma.VersionContext
+import scorex.utils.{Longs, Ints}
 import sigmastate.SCollection.SByteArray
 import sigmastate.Values.ErgoTree.EmptyConstants
-import sigmastate.Values.{ConstantNode, ErgoTree, EvaluatedValue, SValue, SigmaBoolean}
+import sigmastate.Values.{EvaluatedValue, SValue, ConstantNode, ErgoTree, SigmaBoolean}
 import sigmastate._
 import sigmastate.crypto.CryptoConstants.EcPointType
 import sigmastate.crypto.DLogProtocol.ProveDlog
-import sigmastate.crypto.{CryptoConstants, ProveDHTuple}
-import sigmastate.crypto.{CryptoFacade, Ecp}
+import sigmastate.crypto.{ProveDHTuple, CryptoConstants, Ecp, CryptoFacade}
 import sigmastate.eval.Extensions._
 import sigmastate.interpreter.Interpreter
 import sigmastate.serialization.ErgoTreeSerializer.DefaultSerializer
 import sigmastate.serialization.{GroupElementSerializer, SigmaSerializer}
-import sigma._
+import sigma.{VersionContext, _}
 
 import java.math.BigInteger
 import java.util.Arrays
 import scala.annotation.unused
 import scala.reflect.ClassTag
-import scala.util.{Failure, Success}
+import scala.util.{Success, Failure}
 
 /** Interface implmented by wrappers to provide access to the underlying wrapped value. */
 trait WrapperOf[T] {
@@ -154,7 +152,7 @@ case class CSigmaProp(sigmaTree: SigmaBoolean) extends SigmaProp with WrapperOf[
   *
   * @see BatchAVLVerifier
   */
-class AvlTreeVerifier(startingDigest: ADDigest,
+class AvlTreeVerifier private (startingDigest: ADDigest,
                        proof: SerializedAdProof,
                        override val keyLength: Int,
                        override val valueLengthOpt: Option[Int])
@@ -166,6 +164,12 @@ class AvlTreeVerifier(startingDigest: ADDigest,
   override protected def logError(t: Throwable): Unit = {}
 }
 object AvlTreeVerifier {
+  /** Create an instance of [[AvlTreeVerifier]] for the given tree and proof.
+    * Both tree and proof are immutable.
+    * @param tree  represents a tree state to verify
+    * @param proof proof of tree operations leading to the state digest in the tree
+    * @return a new verifier instance
+    */
   def apply(tree: AvlTree, proof: Coll[Byte]): AvlTreeVerifier = {
     val treeData = tree.asInstanceOf[CAvlTree].treeData
     val adProof = SerializedAdProof @@ proof.toArray
@@ -491,7 +495,6 @@ object CHeader {
 class CostingSigmaDslBuilder extends SigmaDslBuilder { dsl =>
   implicit val validationSettings: SigmaValidationSettings = ValidationRules.currentSettings
 
-  // manual fix
   override val Colls: CollBuilder = sigma.Colls
 
   override def BigInt(n: BigInteger): BigInt = CBigInt(n)

interpreter/shared/src/main/scala/sigmastate/eval/Evaluation.scala

@@ -118,7 +118,8 @@ object Evaluation {
   }
 
   /** Tries to reconstruct RType of the given value.
-    * If not successfull returns failure. */
+    * If not successfull returns failure.
+    * NOTE, this method is NOT used in consensus. */
   def rtypeOf(value: Any): Try[RType[_]] = Try { value match {
     case arr if arr.getClass.isArray =>
       val itemClass = arr.getClass.getComponentType
@@ -140,7 +141,11 @@ object Evaluation {
     case _: Unit  => UnitType
     case _: sigma.BigInt => BigIntRType
     case _: GroupElement => GroupElementRType
-    case _: ErgoBox => ErgoBoxRType  // TODO remove this RType
+    // TODO remove this case to allow removing of RType instances
+    //  for ErgoBox, AvlTreeData, SigmaBoolean.
+    //  RType describes only the types that can be put into registers, context variables and
+    //  used as ErgoTree evaluation intermediate values.
+    case _: ErgoBox => ErgoBoxRType
     case _: Box => BoxRType
 
     case _: AvlTreeData => AvlTreeDataRType // TODO remove this RType

interpreter/shared/src/main/scala/sigmastate/sigmastate.scala

@@ -1,15 +1,20 @@
 import org.ergoplatform.{ErgoBox, ErgoBoxCandidate, ErgoLikeContext}
-import sigma.data.{GeneralType, RType}
+import sigma.data.{RType, GeneralType}
 import sigmastate.Values._
 import sigmastate.lang.CheckingSigmaBuilder
 
+import scala.annotation.nowarn
 import scala.reflect.classTag
 
 package object sigmastate {
   import CheckingSigmaBuilder._
 
+  /** Shadow the implicit from sigma package so it doesn't interfere with the resolution
+    * of ClassTags below.
+    */
+  @nowarn private def rtypeToClassTag = ???
+
   /** RType descriptors for predefined types used in AOTC-based interpreter. */
-  def rtypeToClassTag = ???
 
   implicit val SigmaBooleanRType    : RType[SigmaBoolean]     = RType.fromClassTag(classTag[SigmaBoolean])
 

sc/shared/src/main/scala/special/collection/impl/CollsImpl.scala

@@ -332,8 +332,6 @@ class CollCls extends EntityObject("Coll") {
     def map[A,B](xs: Ref[Coll[A]])(f: Ref[A] => Ref[B]) = { implicit val eA = unlift(xs.elem); xs.map(fun(f))}
   }
 
-  // manual fix: CollIso, collIso
-
   // familyElem
   class CollElem[A, To <: Coll[A]](implicit _eA: Elem[A])
     extends EntityElem1[A, To, Coll](_eA, container[Coll]) {
@@ -354,8 +352,6 @@ class CollCls extends EntityObject("Coll") {
   implicit final def collElement[A](implicit eA: Elem[A]): Elem[Coll[A]] =
     cachedElemByClass(eA)(RClass(classOf[CollElem[A, Coll[A]]]))
 
-  // manual fix: ViewColl
-
   object CollMethods {
     object length {
       def unapply(d: Def[_]): Nullable[Ref[Coll[A]] forSome {type A}] = d match {

sc/shared/src/main/scala/special/sigma/impl/SigmaDslImpl.scala

@@ -437,15 +437,13 @@ object SigmaProp extends EntityObject("SigmaProp") {
         true, false, element[Coll[Byte]]))
     }
 
-    // manual fix &&
     override def &&(other: Ref[SigmaProp]): Ref[SigmaProp] = {
       asRep[SigmaProp](mkMethodCall(self,
         SigmaPropClass.getMethod("$amp$amp", classOf[Sym]),
         Array[AnyRef](other),
         true, false, element[SigmaProp]))
     }
 
-    // manual fix ||
     override def ||(other: Ref[SigmaProp]): Ref[SigmaProp] = {
       asRep[SigmaProp](mkMethodCall(self,
         SigmaPropClass.getMethod("$bar$bar", classOf[Sym]),
@@ -486,15 +484,13 @@ object SigmaProp extends EntityObject("SigmaProp") {
         true, true, element[Coll[Byte]]))
     }
 
-    // manual fix &&
     def &&(other: Ref[SigmaProp]): Ref[SigmaProp] = {
       asRep[SigmaProp](mkMethodCall(source,
         SigmaPropClass.getMethod("$amp$amp", classOf[Sym]),
         Array[AnyRef](other),
         true, true, element[SigmaProp]))
     }
 
-    // manual fix ||
     def ||(other: Ref[SigmaProp]): Ref[SigmaProp] = {
       asRep[SigmaProp](mkMethodCall(source,
         SigmaPropClass.getMethod("$bar$bar", classOf[Sym]),