Third defect type

.scalafix.conf

@@ -41,7 +41,9 @@ DisableSyntax {
   noNulls = true
   noReturns = true
   noWhileLoops = true
-  noAsInstanceOf = true
+
+  // TODO: set this to true when I find a way to avoid explicit casts
+  noAsInstanceOf = false
   noIsInstanceOf = true
   noXml = true
   noDefaultArgs = false

.scalafmt.conf

@@ -1,4 +1,6 @@
-version = 3.0.4
+version = 3.4.3
+lineEndings = preserve
+runner.dialect = scala213
 
 project {
   includePaths = [
@@ -7,7 +9,10 @@ project {
     "glob:**.sc",
     "glob:**.md",
   ]
-  excludePaths = []
+  excludePaths = [
+    // TODO: Investigate why this file causes scalafmt to crash
+    "glob:**/inlining/Inliner.scala"
+  ]
 }
 
 fileOverride {

analysis/src/main/scala/org/polystat/odin/analysis/EOOdinAnalyzer.scala

@@ -1,12 +1,15 @@
 package org.polystat.odin.analysis
 
-import cats.ApplicativeError
+import cats.ApplicativeThrow
+import cats.data.EitherNel
 import cats.effect.Sync
 import cats.syntax.either._
 import cats.syntax.foldable._
 import fs2.Stream
 import monix.newtypes.NewtypeWrapped
 import org.polystat.odin.analysis.EOOdinAnalyzer.OdinAnalysisError
+import org.polystat.odin.analysis.inlining.Inliner
+import org.polystat.odin.analysis.logicalexprs.ExtractLogic
 import org.polystat.odin.analysis.mutualrec.advanced.Analyzer.analyzeAst
 import org.polystat.odin.analysis.mutualrec.naive.findMutualRecursionFromAst
 import org.polystat.odin.core.ast.EOProg
@@ -52,16 +55,14 @@ object EOOdinAnalyzer {
 
     }
 
-  def advancedMutualRecursionAnalyzer[F[_]](implicit
-    F: ApplicativeError[F, Throwable],
-  ): ASTAnalyzer[F] =
+  def advancedMutualRecursionAnalyzer[F[_]: ApplicativeThrow]: ASTAnalyzer[F] =
     new ASTAnalyzer[F] {
 
       override def analyze(
         ast: EOProg[EOExprOnly]
       ): Stream[F, OdinAnalysisError] = for {
         errors <- Stream.eval(
-          F.fromEither(
+          ApplicativeThrow[F].fromEither(
             analyzeAst[Either[String, *]](ast).leftMap(new Exception(_))
           )
         )
@@ -70,13 +71,43 @@ object EOOdinAnalyzer {
 
     }
 
-  def analyzeSourceCode[EORepr, F[_]](analyzer: ASTAnalyzer[F])(
+  def unjustifiedAssumptionAnalyzer[F[_]: ApplicativeThrow]: ASTAnalyzer[F] =
+    new ASTAnalyzer[F] {
+
+      private[this] def toThrow[A](eitherNel: EitherNel[String, A]): F[A] = {
+        ApplicativeThrow[F].fromEither(
+          eitherNel
+            .leftMap(_.mkString_(util.Properties.lineSeparator))
+            .leftMap(new Exception(_))
+        )
+      }
+
+      override def analyze(
+        ast: EOProg[EOExprOnly]
+      ): Stream[F, OdinAnalysisError] =
+        Stream.evals {
+          toThrow {
+            for {
+              tree <- Inliner.zipMethodsWithTheirInlinedVersionsFromParent(ast)
+              errors <- ExtractLogic.processObjectTree(tree)
+            } yield errors.map(OdinAnalysisError.apply)
+          }
+        }
+
+    }
+
+  def analyzeSourceCode[EORepr, F[_]](
+    analyzer: ASTAnalyzer[F]
+  )(
     eoRepr: EORepr
   )(implicit
     parser: EoParser[EORepr, F, EOProg[EOExprOnly]]
   ): Stream[F, OdinAnalysisError] = for {
     programAst <- Stream.eval(parser.parse(eoRepr))
-    mutualRecursionErrors <- analyzer.analyze(programAst)
+    mutualRecursionErrors <-
+      analyzer
+        .analyze(programAst)
+        .handleErrorWith(_ => Stream.empty)
   } yield mutualRecursionErrors
 
 }

analysis/src/main/scala/org/polystat/odin/analysis/inlining/Abstract.scala

@@ -0,0 +1,98 @@
+package org.polystat.odin.analysis.inlining
+
+import cats.syntax.foldable._
+import cats.syntax.functor._
+import cats.syntax.semigroup._
+import cats.{Applicative, Eval, Foldable, Id, Monoid}
+import com.github.tarao.nonempty.collection.NonEmpty
+import higherkindness.droste.data.Fix
+import org.polystat.odin.analysis.inlining.Optics.{lenses, traversals}
+import org.polystat.odin.core.ast._
+import org.polystat.odin.core.ast.astparams.EOExprOnly
+
+object Abstract {
+
+  private type NonEmptyVector[A] = NonEmpty[A, Vector[A]]
+
+  implicit private val nonEmptyFoldable: Foldable[NonEmptyVector] =
+    new Foldable[NonEmptyVector] {
+
+      override def foldLeft[A, B](fa: NonEmptyVector[A], b: B)(
+        f: (B, A) => B
+      ): B =
+        fa.value.foldLeft(b)(f)
+
+      override def foldRight[A, B](fa: NonEmptyVector[A], lb: Eval[B])(
+        f: (A, Eval[B]) => Eval[B]
+      ): Eval[B] =
+        f(fa.head, fa.tail.foldRightDefer(lb)(f))
+
+    }
+
+  def modifyExprWithState[F[_]: Applicative, S](
+    initialState: S,
+    initialDepth: BigInt = 0
+  )(modifyExpr: S => BigInt => EOExprOnly => F[EOExprOnly])(
+    modifyState: EOExpr[EOExprOnly] => BigInt => S => S
+  )(expr: EOExprOnly): F[EOExprOnly] = {
+    def recurse(depth: BigInt)(state: S)(subExpr: EOExprOnly): F[EOExprOnly] = {
+      Fix.un(subExpr) match {
+        case obj: EOObj[EOExprOnly] =>
+          traversals
+            .eoObjBndAttrExprs
+            .modifyA(recurse(depth + 1)(modifyState(obj)(depth + 1)(state)))(
+              obj
+            )
+            .map(Fix(_))
+        case copy: EOCopy[EOExprOnly] =>
+          traversals
+            .eoCopy
+            .modifyA(recurse(depth)(modifyState(copy)(depth)(state)))(copy)
+            .map(Fix(_))
+        case dot: EODot[EOExprOnly] =>
+          lenses
+            .focusDotSrc
+            .modifyA(recurse(depth)(modifyState(dot)(depth)(state)))(dot)
+            .map(Fix(_))
+        case array: EOArray[EOExprOnly] =>
+          traversals
+            .eoArrayElems
+            .modifyA(recurse(depth)(modifyState(array)(depth)(state)))(array)
+            .map(Fix(_))
+        case other => modifyExpr(state)(depth)(Fix(other))
+      }
+    }
+    recurse(initialDepth)(initialState)(expr)
+  }
+
+  def modifyExpr(
+    modify: BigInt => EOExprOnly => EOExprOnly,
+    initialDepth: BigInt = 0
+  )(expr: EOExprOnly): EOExprOnly = {
+    modifyExprWithState[Id, Unit]((), initialDepth)(_ =>
+      depth => expr => modify(depth)(expr)
+    )(_ => _ => identity)(expr)
+  }
+
+  def foldAst[A: Monoid](
+    binds: Vector[EOBnd[EOExprOnly]]
+  )(f: PartialFunction[EOExpr[EOExprOnly], A]): A = {
+    def recurse(bnd: EOBnd[EOExprOnly]): A = {
+      f.lift(Fix.un(bnd.expr)) match {
+        case Some(value) => value
+        case None => Fix.un(bnd.expr) match {
+            case EOObj(_, _, bndAttrs) => bndAttrs.foldMap(recurse)
+            case EOCopy(trg, args) =>
+              recurse(EOAnonExpr(trg)).combine(
+                Foldable[NonEmptyVector].foldMap(args)(recurse)
+              )
+            case EODot(trg, _) => recurse(EOAnonExpr(trg))
+            case EOArray(elems) => elems.foldMap(recurse)
+            case _ => Monoid[A].empty
+          }
+      }
+    }
+    binds.foldMap(recurse)
+  }
+
+}

analysis/src/main/scala/org/polystat/odin/analysis/inlining/Context.scala

@@ -1,12 +1,11 @@
 package org.polystat.odin.analysis.inlining
 
-import cats.data.EitherNel
-import cats.syntax.either._
-import cats.syntax.traverse._
+import cats.data.{EitherNel, NonEmptyList => Nel}
 import higherkindness.droste.data.Fix
+import org.polystat.odin.analysis.inlining.Optics._
+import Abstract.modifyExprWithState
 import org.polystat.odin.core.ast._
 import org.polystat.odin.core.ast.astparams.EOExprOnly
-import cats.data.{NonEmptyList => Nel}
 
 // 0. Resolve explicit locator chains (^.^.aboba) during parsing
 // 1. Create the first context that includes names of all top-lvl EOObjs
@@ -28,86 +27,65 @@ object Context {
     ctx: Context,
     name: String,
     currentDepth: BigInt
-  ): EitherNel[String, EOExprOnly] = {
-    val result = ctx
+  ): EitherNel[String, EOExprOnly] =
+    ctx
       .get(name)
-      .map(depth => {
-        val tmp: EOSimpleAppWithLocator[EOExprOnly] =
-          EOSimpleAppWithLocator(name, currentDepth - depth)
-        Fix(tmp)
-      })
-
-    Either.fromOption(
-      result,
-      Nel.one(s"Could not set locator for non-existent object with name $name")
-    )
-  }
+      .map(depth =>
+        Fix[EOExpr](EOSimpleAppWithLocator(name, currentDepth - depth))
+      )
+      .toRight(
+        Nel.one(
+          s"Could not set locator for non-existent object with name \"$name\""
+        )
+      )
 
   def rebuildContext(
     ctx: Context,
     currentDepth: BigInt,
     objs: Vector[EOBnd[EOExprOnly]],
-    freeAttrs: Option[Vector[LazyName]]
+    freeAttrs: Vector[LazyName]
   ): Context = {
     val objCtx = objs
       .collect { case bndExpr: EOBndExpr[Fix[EOExpr]] => bndExpr }
-      .map(bnd => bnd.bndName.name.name -> currentDepth)
+      .map(bnd => (bnd.bndName.name.name, currentDepth))
       .toMap
-    val argCtx = freeAttrs match {
-      case Some(value) => value.map(lName => lName.name -> currentDepth).toMap
-      case None => Map.empty
-    }
-
+    val argCtx = freeAttrs.map(lName => (lName.name, currentDepth)).toMap
     ctx ++ objCtx ++ argCtx
   }
 
   def setLocators(
     code: EOProg[EOExprOnly]
   ): EitherNel[String, EOProg[EOExprOnly]] = {
-    def recurse(ctx: Context, depth: BigInt)(
-      expr: EOExprOnly
-    ): EitherNel[String, EOExprOnly] =
-      Fix.un(expr) match {
-        case obj @ EOObj(freeAttrs, _, bndAttrs) =>
-          val newDepth = depth + 1
-          val newCtx = rebuildContext(ctx, newDepth, bndAttrs, Some(freeAttrs))
-
-          Optics
-            .traversals
-            .eoObjBndAttrs
-            .modifyA(recurse(newCtx, newDepth))(obj)
-            .map(Fix(_))
-
-        case app: EOSimpleApp[Fix[EOExpr]] =>
-          resolveLocator(ctx, app.name, depth)
-
-        case copy: EOCopy[EOExprOnly] =>
-          Optics
-            .traversals
-            .eoCopy
-            .modifyA(recurse(ctx, depth))(copy)
-            .map(Fix(_))
-
-        case dot: EODot[EOExprOnly] =>
-          Optics
-            .lenses
-            .focusDotSrc
-            .modifyA(recurse(ctx, depth))(dot)
-            .map(Fix(_))
-        case other => Right(Fix(other))
-      }
-
     val initialCtx =
-      rebuildContext(Map(), 0, code.bnds, None)
-    val newBnds = code
-      .bnds
-      .traverse(bnd =>
-        for {
-          newExpr <- recurse(initialCtx, 0)(bnd.expr)
-        } yield Optics.lenses.focusFromBndToExpr.replace(newExpr)(bnd)
+      rebuildContext(
+        Map(
+          "seq" -> 0,
+          "assert" -> 0,
+        ),
+        0,
+        code.bnds,
+        Vector()
       )
-
-    newBnds.map(bnds => code.copy(bnds = bnds))
+    val modify = modifyExprWithState(initialCtx)(modifyExpr =
+      ctx =>
+        depth =>
+          expr =>
+            Fix.un(expr) match {
+              case app: EOSimpleApp[EOExprOnly] =>
+                resolveLocator(ctx, app.name, depth)
+              case other => Right(Fix(other))
+            }
+    )(modifyState =
+      expr =>
+        depth =>
+          prev =>
+            expr match {
+              case EOObj(freeAttrs, _, bndAttrs) =>
+                rebuildContext(prev, depth, bndAttrs, freeAttrs)
+              case _ => prev
+            }
+    )(_)
+    traversals.eoProg.modifyA(modify)(code)
 
   }