chore(compiler): Refactor exports handling [LNG-289]

model/inline/src/main/scala/aqua/model/inline/ArrowInliner.scala

@@ -3,7 +3,7 @@ package aqua.model.inline
 import aqua.errors.Errors.internalError
 import aqua.model
 import aqua.model.*
-import aqua.model.inline.state.{Arrows, Exports, Mangler}
+import aqua.model.inline.state.{Exports, Mangler}
 import aqua.raw.ops.RawTag
 import aqua.raw.value.{ValueRaw, VarRaw}
 import aqua.types.*
@@ -26,7 +26,7 @@ import scribe.Logging
  */
 object ArrowInliner extends Logging {
 
-  def callArrow[S: Exports: Arrows: Mangler](
+  def callArrow[S: Exports: Mangler](
     arrow: FuncArrow,
     call: CallModel
   ): State[S, OpModel.Tree] =
@@ -42,7 +42,7 @@ object ArrowInliner extends Logging {
       )
 
   // push results to streams if they are exported to streams
-  private def pushStreamResults[S: Mangler: Exports: Arrows](
+  private def pushStreamResults[S: Mangler: Exports](
     outsideStreamNames: Set[String],
     exportTo: List[CallModel.Export],
     results: List[ValueRaw]
@@ -83,7 +83,7 @@ object ArrowInliner extends Logging {
   )
 
   // Apply a callable function, get its fully resolved body & optional value, if any
-  private def inline[S: Mangler: Arrows: Exports](
+  private def inline[S: Mangler: Exports](
     fn: FuncArrow,
     call: CallModel,
     outsideDeclaredStreams: Set[String]
@@ -116,7 +116,8 @@ object ArrowInliner extends Logging {
 
     // find and get resolved arrows if we return them from the function
     returnedArrows = rets.collect { case VarModel(name, _: ArrowType, _) => name }.toSet
-    arrowsToSave <- Arrows[S].pickArrows(returnedArrows)
+    // TODO: rewrite
+    // arrowsToSave <- Arrows[S].pickArrows(returnedArrows)
 
     body = SeqModel.wrap(callableFuncBody :: ops)
   } yield InlineResult(
@@ -213,13 +214,14 @@ object ArrowInliner extends Logging {
     }
   }
 
-  private def getAbilityArrows[S: Arrows: Exports](
+  private def getAbilityArrows[S: Exports](
     name: String,
     `type`: GeneralAbilityType
   ): State[S, Map[String, FuncArrow]] = for {
     exports <- Exports[S].exports
-    arrows <- Arrows[S].arrows
-  } yield getAbilityArrows(name, None, `type`, exports, arrows)
+    // TODO: Rewrite
+    // arrows <- Arrows[S].arrows
+  } yield getAbilityArrows(name, None, `type`, exports, ???)
 
   final case class Renamed[T](
     renames: Map[String, String],
@@ -298,9 +300,10 @@ object ArrowInliner extends Logging {
     }
 
     // Gather abilities related arrows
-    val abilitiesArrows = abilitiesValues.toList.foldMap { case (_, (_, values)) =>
-      Arrows.arrowsByValues(fn.capturedArrows, values).toList
-    }.toMap
+    val abilitiesArrows = ???
+    // abilitiesValues.toList.foldMap { case (_, (_, values)) =>
+    //   Arrows.arrowsByValues(fn.capturedArrows, values).toList
+    // }.toMap
 
     // Gather all other values and arrows that are not related to abilities
     val otherValues = fn.capturedValues -- abilitiesValuesKeys
@@ -354,10 +357,11 @@ object ArrowInliner extends Logging {
 
       // Rename values and arrows unrelated to abilities
       otherValuesRenamed <- findNewNames(otherValues)
-      otherArrowsValues = Arrows.arrowsByValues(
-        otherArrows,
-        otherValues
-      )
+      otherArrowsValues = ???
+      // Arrows.arrowsByValues(
+      //   otherArrows,
+      //   otherValues
+      // )
       otherArrowsValuesRenamed = Renamed(
         otherValuesRenamed.renames.filterKeys(otherArrowsValues.keySet).toMap,
         otherArrowsValues.renamed(otherValuesRenamed.renames)
@@ -414,7 +418,7 @@ object ArrowInliner extends Logging {
    * @param arrows Arrows that are available for callee
    * @return Prepared function
    */
-  private def prelude[S: Mangler: Arrows: Exports](
+  private def prelude[S: Mangler: Exports](
     fn: FuncArrow,
     call: CallModel,
     exports: Map[String, ValueModel],
@@ -481,35 +485,37 @@ object ArrowInliner extends Logging {
 
     ret = fn.ret.map(_.renameVars(renaming))
 
-    _ <- Arrows[S].resolved(arrowsResolved)
+    // TODO: Rewrite
+    // _ <- Arrows[S].resolved(arrowsResolved)
     _ <- Exports[S].resolved(exportsResolved)
   } yield (fn.copy(body = treeWithCanons, ret = ret), SeqModel.wrap(canons))
 
-  private[inline] def callArrowRet[S: Exports: Arrows: Mangler](
+  private[inline] def callArrowRet[S: Exports: Mangler](
     arrow: FuncArrow,
     call: CallModel
   ): State[S, (OpModel.Tree, List[ValueModel])] = for {
-    passArrows <- Arrows[S].pickArrows(call.arrowArgNames)
+    // TODO: Rewrite
+    // passArrows <- Arrows[S].pickArrows(call.arrowArgNames)
     arrowsFromAbilities <- call.abilityArgs
       .traverse(getAbilityArrows.tupled)
       .map(_.flatMap(_.toList).toMap)
+    passArrows = ???
 
     exports <- Exports[S].exports
     streams <- getOutsideStreamNames
     arrows = passArrows ++ arrowsFromAbilities
-    
+
     inlineResult <- Exports[S].scope(
-      Arrows[S].scope(
-        for {
-          // Process renamings, prepare environment
-          fnCanon <- ArrowInliner.prelude(arrow, call, exports, arrows)
-          inlineResult <- ArrowInliner.inline(fnCanon._1, call, streams)
-        } yield inlineResult.copy(tree = SeqModel.wrap(fnCanon._2, inlineResult.tree))
-      )
+      for {
+        // Process renamings, prepare environment
+        fnCanon <- ArrowInliner.prelude(arrow, call, exports, arrows)
+        inlineResult <- ArrowInliner.inline(fnCanon._1, call, streams)
+      } yield inlineResult.copy(tree = SeqModel.wrap(fnCanon._2, inlineResult.tree))
     )
 
     exportTo = call.exportTo.map(_.name)
-    _ <- Arrows[S].resolved(inlineResult.arrowsToSave)
+    // TODO: Rewrite
+    // _ <- Arrows[S].resolved(inlineResult.arrowsToSave)
     _ <- Exports[S].resolved(
       exportTo
         .zip(inlineResult.returnedValues)

model/inline/src/main/scala/aqua/model/inline/MakeStructRawInliner.scala

@@ -1,15 +1,15 @@
 package aqua.model.inline
 
+import aqua.model.*
 import aqua.model.inline.RawValueInliner.unfold
 import aqua.model.inline.raw.RawInliner
-import aqua.model.inline.state.{Arrows, Exports, Mangler}
-import aqua.model.*
+import aqua.model.inline.state.{Exports, Mangler}
 import aqua.raw.value.MakeStructRaw
 import aqua.types.{StreamMapType, StructType}
 
 import cats.data.{Chain, NonEmptyMap, State}
-import cats.syntax.foldable.*
 import cats.syntax.bifunctor.*
+import cats.syntax.foldable.*
 import cats.syntax.functor.*
 
 object MakeStructRawInliner extends RawInliner[MakeStructRaw] {
@@ -58,7 +58,7 @@ object MakeStructRawInliner extends RawInliner[MakeStructRaw] {
     constructThroughMap(mapName, mapType, CallModel.Export(resultName, resultType), fields)
   }
 
-  override def apply[S: Mangler: Exports: Arrows](
+  override def apply[S: Mangler: Exports](
     raw: MakeStructRaw,
     propertiesAllowed: Boolean
   ): State[S, (ValueModel, Inline)] = {

model/inline/src/main/scala/aqua/model/inline/RawValueInliner.scala

@@ -3,7 +3,8 @@ package aqua.model.inline
 import aqua.model.*
 import aqua.model.inline.Inline.MergeMode.*
 import aqua.model.inline.raw.*
-import aqua.model.inline.state.{Arrows, Counter, Exports, Mangler}
+import aqua.model.inline.state.Exports.Export
+import aqua.model.inline.state.{Counter, Exports, Mangler}
 import aqua.raw.ops.*
 import aqua.raw.value.*
 import aqua.types.{ArrayType, LiteralType, OptionType, StreamType}
@@ -23,21 +24,26 @@ object RawValueInliner extends Logging {
 
   import aqua.model.inline.Inline.*
 
-  private[inline] def unfold[S: Mangler: Exports: Arrows](
+  private[inline] def unfold[S: Mangler: Exports](
     raw: ValueRaw,
     propertiesAllowed: Boolean = true
-  ): State[S, (ValueModel, Inline)] = for {
+  ): State[S, (Export, Inline)] = for {
     optimized <- StateT.liftF(Optimization.optimize(raw))
     _ <- StateT.liftF(Eval.later(logger.trace("OPTIMIZIED " + optimized)))
     result <- optimized match {
+      case LiteralRaw(value, t) =>
+        val model = LiteralModel(value, t)
+        val exp = Export.Value(model)
+        State.pure(exp -> Inline.empty)
+
       case VarRaw(name, t) =>
         for {
-          exports <- Exports[S].exports
-          model = VarModel(name, t, Chain.empty).resolveWith(exports)
-        } yield model -> Inline.empty
-
-      case LiteralRaw(value, t) =>
-        State.pure(LiteralModel(value, t) -> Inline.empty)
+          maybeExport <- Exports[S].get(name)
+          model = VarModel(name, t)
+          exp = maybeExport.getOrElse(
+            Export.Value(model)
+          )
+        } yield exp -> Inline.empty
 
       case alr: ApplyPropertyRaw =>
         ApplyPropertiesRawInliner(alr, propertiesAllowed)
@@ -69,15 +75,15 @@ object RawValueInliner extends Logging {
     }
   } yield result
 
-  private[inline] def inlineToTree[S: Mangler: Exports: Arrows](
+  private[inline] def inlineToTree[S: Mangler: Exports](
     inline: Inline
   ): State[S, List[OpModel.Tree]] =
     (inline.mergeMode match {
       case SeqMode => SeqModel.wrap(inline.predo) :: Nil
       case ParMode => inline.predo.toList
     }).pure
 
-  private[inline] def toModel[S: Mangler: Exports: Arrows](
+  private[inline] def toModel[S: Mangler: Exports](
     unfoldF: State[S, (ValueModel, Inline)]
   ): State[S, (ValueModel, Option[OpModel.Tree])] =
     for {
@@ -92,15 +98,15 @@ object RawValueInliner extends Logging {
       _ = logger.trace("map was: " + map)
     } yield vm -> parDesugarPrefix(ops.filterNot(_ == EmptyModel.leaf))
 
-  def valueToModel[S: Mangler: Exports: Arrows](
+  def valueToModel[S: Mangler: Exports](
     value: ValueRaw,
     propertiesAllowed: Boolean = true
   ): State[S, (ValueModel, Option[OpModel.Tree])] = for {
     _ <- StateT.liftF(Eval.later(logger.trace("RAW " + value)))
     model <- toModel(unfold(value, propertiesAllowed))
   } yield model
 
-  def valueListToModel[S: Mangler: Exports: Arrows](
+  def valueListToModel[S: Mangler: Exports](
     values: List[ValueRaw]
   ): State[S, List[(ValueModel, Option[OpModel.Tree])]] =
     values.traverse(valueToModel(_))
@@ -109,14 +115,14 @@ object RawValueInliner extends Logging {
    * Unfold all arguments and make CallModel
    * @param flatStreamArguments canonicalize and flatten all stream arguments if true
    */
-  def callToModel[S: Mangler: Exports: Arrows](
+  def callToModel[S: Mangler: Exports](
     call: Call,
     flatStreamArguments: Boolean
   ): State[S, (CallModel, Option[OpModel.Tree])] = {
     valueListToModel(call.args).flatMap { args =>
       if (flatStreamArguments)
         args.map { arg =>
-          TagInliner.flat(arg._1, arg._2)
+          TagInliner.flat(arg._1, arg._2, true)
         }.sequence
       else
         State.pure(args)

model/inline/src/main/scala/aqua/model/inline/TagInliner.scala

@@ -3,7 +3,7 @@ package aqua.model.inline
 import aqua.errors.Errors.internalError
 import aqua.model.*
 import aqua.model.inline.raw.{CallArrowRawInliner, CallServiceRawInliner}
-import aqua.model.inline.state.{Arrows, Exports, Mangler}
+import aqua.model.inline.state.{Exports, Mangler}
 import aqua.model.inline.tag.IfTagInliner
 import aqua.raw.ops.*
 import aqua.raw.value.*
@@ -193,7 +193,7 @@ object TagInliner extends Logging {
    * @tparam S Current state
    * @return Model (if any), and prefix (if any)
    */
-  def tagToModel[S: Mangler: Arrows: Exports](
+  def tagToModel[S: Mangler: Exports](
     tag: RawTag
   ): State[S, TagInlined[S]] =
     tag match {
@@ -374,11 +374,13 @@ object TagInliner extends Logging {
         } yield TagInlined.Empty(prefix = prefix)
 
       case ClosureTag(arrow, detach) =>
-        if (detach) Arrows[S].resolved(arrow, None).as(TagInlined.Empty())
-        else
-          Arrows[S]
-            .resolved(arrow, arrow.name.some)
-            .as(TagInlined.Single(model = CaptureTopologyModel(arrow.name)))
+        ???
+      // TODO: Rewrite
+      // if (detach) Arrows[S].resolved(arrow, None).as(TagInlined.Empty())
+      // else
+      //   Arrows[S]
+      //     .resolved(arrow, arrow.name.some)
+      //     .as(TagInlined.Single(model = CaptureTopologyModel(arrow.name)))
 
       case NextTag(item) =>
         for {
@@ -431,12 +433,13 @@ object TagInliner extends Logging {
               } yield methodName -> fn
           }
 
+          // TODO: Rewrite
           // Resolve wrappers in arrows
-          _ <- Arrows[S].resolved(
-            methods.map { case (_, fn) =>
-              fn.funcName -> fn
-            }.toMap
-          )
+          // _ <- Arrows[S].resolved(
+          //   methods.map { case (_, fn) =>
+          //     fn.funcName -> fn
+          //   }.toMap
+          // )
 
           // Resolve wrappers in exports
           _ <- methods.traverse { case (methodName, fn) =>
@@ -475,7 +478,7 @@ object TagInliner extends Logging {
       inlined <- headInlined.build(children)
     } yield inlined
 
-  def handleTree[S: Exports: Mangler: Arrows](
+  def handleTree[S: Exports: Mangler](
     tree: RawTag.Tree
   ): State[S, OpModel.Tree] =
     traverseS(tree, tagToModel(_))