Detecting direct access to base class state (4th defect type)

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

@@ -1,14 +1,15 @@
 package org.polystat.odin.analysis
 
 import cats._
-import cats.data.EitherNel
+import cats.data.{EitherNel, NonEmptyList}
 import cats.effect.Sync
 import cats.syntax.all._
 import fs2.Stream
 import org.polystat.odin.analysis.EOOdinAnalyzer._
 import org.polystat.odin.analysis.liskov.Analyzer
 import org.polystat.odin.analysis.mutualrec.advanced.Analyzer.analyzeAst
 import org.polystat.odin.analysis.mutualrec.naive.findMutualRecursionFromAst
+import org.polystat.odin.analysis.stateaccess.DetectStateAccess
 import org.polystat.odin.analysis.utils.inlining.Inliner
 import org.polystat.odin.core.ast.EOProg
 import org.polystat.odin.core.ast.astparams.EOExprOnly
@@ -29,9 +30,9 @@ object EOOdinAnalyzer {
 
     final case class Ok(override val ruleId: String) extends OdinAnalysisResult
 
-    final case class DefectDetected(
+    final case class DefectsDetected(
       override val ruleId: String,
-      message: String
+      messages: NonEmptyList[String],
     ) extends OdinAnalysisResult
 
     final case class AnalyzerFailure(
@@ -42,10 +43,10 @@ object EOOdinAnalyzer {
     def fromErrors(
       analyzer: String
     )(errors: List[String]): OdinAnalysisResult =
-      if (errors.isEmpty)
-        Ok(analyzer)
-      else
-        DefectDetected(analyzer, errors.mkString("\n"))
+      errors match {
+        case e :: es => DefectsDetected(analyzer, NonEmptyList(e, es))
+        case Nil => Ok(analyzer)
+      }
 
     def fromThrow[F[_]: ApplicativeThrow](
       analyzer: String
@@ -99,7 +100,10 @@ object EOOdinAnalyzer {
           })
         } yield odinError
 
-        stream.compile.toList.map(OdinAnalysisResult.fromErrors(name))
+        stream
+          .compile
+          .toList
+          .map(OdinAnalysisResult.fromErrors(name))
       }
 
     }
@@ -127,14 +131,6 @@ object EOOdinAnalyzer {
 
       override val name: String = "Unjustified Assumption"
 
-      private def toThrow[A](eitherNel: EitherNel[String, A]): F[A] = {
-        MonadThrow[F].fromEither(
-          eitherNel
-            .leftMap(_.mkString_(util.Properties.lineSeparator))
-            .leftMap(new Exception(_))
-        )
-      }
-
       override def analyze(
         ast: EOProg[EOExprOnly]
       ): F[OdinAnalysisResult] =
@@ -170,12 +166,33 @@ object EOOdinAnalyzer {
 
     }
 
-  def analyzeSourceCode[EORepr, F[_]: Monad](
+  def directStateAccessAnalyzer[F[_]: MonadThrow]: ASTAnalyzer[F] =
+    new ASTAnalyzer[F] {
+
+      override val name: String = "Direct Access to Superclass State"
+
+      override def analyze(
+        ast: EOProg[EOExprOnly]
+      ): F[OdinAnalysisResult] =
+        OdinAnalysisResult.fromThrow[F](name) {
+          for {
+            tmpTree <-
+              toThrow(Inliner.createObjectTree(ast))
+            tree <- toThrow(Inliner.resolveParents(tmpTree))
+            errors <-
+              toThrow(DetectStateAccess.analyze(tree))
+          } yield errors
+        }
+
+    }
+
+  def analyzeSourceCode[EORepr, F[_]](
     analyzer: ASTAnalyzer[F]
   )(
     eoRepr: EORepr
   )(implicit
-    parser: EoParser[EORepr, F, EOProg[EOExprOnly]]
+    m: Monad[F],
+    parser: EoParser[EORepr, F, EOProg[EOExprOnly]],
   ): F[OdinAnalysisResult] = for {
     programAst <- parser.parse(eoRepr)
     mutualRecursionErrors <-

analysis/src/main/scala/org/polystat/odin/analysis/stateaccess/DetectStateAccess.scala

@@ -0,0 +1,178 @@
+package org.polystat.odin.analysis.stateaccess
+
+import cats.data.EitherNel
+import higherkindness.droste.data.Fix
+import org.polystat.odin.analysis.utils.Abstract
+import org.polystat.odin.analysis.utils.inlining._
+import org.polystat.odin.core.ast._
+import org.polystat.odin.core.ast.astparams.EOExprOnly
+
+import scala.annotation.tailrec
+
+object DetectStateAccess {
+
+  type ObjInfo = ObjectInfo[ParentInfo[MethodInfo, ObjectInfo], MethodInfo]
+
+  case class State(
+    containerName: String,
+    statePath: List[String],
+    states: Vector[EONamedBnd]
+  )
+
+  case class StateChange(
+    method: EONamedBnd,
+    state: EONamedBnd,
+    statePath: List[String]
+  )
+
+  def collectNestedStates(mainParent: String)(
+    subTree: Inliner.CompleteObjectTree
+  ): Vector[State] = {
+    val currentLvlStateNames = subTree
+      .info
+      .bnds
+      .collect {
+        case BndItself(
+               EOBndExpr(
+                 bndName,
+                 EOSimpleAppWithLocator("memory" | "cage", _)
+               )
+             ) => bndName
+      }
+
+    Vector(
+      State(mainParent, subTree.info.fqn.names.tail, currentLvlStateNames)
+    ) ++
+      subTree
+        .children
+        .flatMap(t => collectNestedStates(mainParent)(t._2))
+  }
+
+  def accumulateParentState(tree: Map[EONamedBnd, Inliner.CompleteObjectTree])(
+    currentParentLink: Option[ParentInfo[MethodInfo, ObjectInfo]],
+    existingStates: Vector[EONamedBnd] = Vector()
+  ): Vector[State] = {
+    currentParentLink match {
+      case Some(parentLink) =>
+        val parentObj = parentLink.linkToParent.getOption(tree).get
+        val currentObjName = parentObj.info.name.name.name
+        val currentLvlStateNames = parentObj
+          .info
+          .bnds
+          .collect {
+            case BndItself(
+                   EOBndExpr(
+                     bndName,
+                     EOSimpleAppWithLocator("memory" | "cage", _)
+                   )
+                 ) if !existingStates.contains(bndName) =>
+              bndName
+          }
+        val currentLvlState =
+          State(currentObjName, List(), currentLvlStateNames)
+        val nestedStates = parentObj
+          .children
+          .flatMap(c =>
+            collectNestedStates(parentObj.info.name.name.name)(c._2)
+          )
+          .toVector
+
+        Vector(currentLvlState) ++ nestedStates ++
+          accumulateParentState(tree)(
+            parentObj.info.parentInfo,
+            existingStates ++ currentLvlStateNames
+          )
+
+      case None => Vector()
+    }
+  }
+
+  def getAccessedStates(method: (EONamedBnd, MethodInfo)): List[StateChange] = {
+    @tailrec
+    def hasSelfAsSource(dot: EODot[EOExprOnly]): Boolean = {
+      Fix.un(dot.src) match {
+        case EOSimpleAppWithLocator("self", x) if x == 0 => true
+        case innerDot @ EODot(_, _) => hasSelfAsSource(innerDot)
+        case _ => false
+      }
+    }
+
+    def buildDotChain(dot: EODot[EOExprOnly]): List[String] =
+      Fix.un(dot.src) match {
+        case EOSimpleAppWithLocator("self", x) if x == 0 => List()
+        case innerDot @ EODot(_, _) =>
+          buildDotChain(innerDot).appended(innerDot.name)
+        case _ => List()
+      }
+
+    val binds = method._2.body.bndAttrs
+
+    def processDot(
+      innerDot: EODot[Fix[EOExpr]],
+      state: String
+    ): List[StateChange] = {
+      val stateName = EOAnyNameBnd(LazyName(state))
+      val containerChain = buildDotChain(innerDot)
+
+      List(StateChange(method._1, stateName, containerChain))
+    }
+
+    Abstract.foldAst[List[StateChange]](binds) {
+      case EOCopy(Fix(dot @ EODot(Fix(innerDot @ EODot(_, state)), _)), _)
+           if hasSelfAsSource(dot) =>
+        processDot(innerDot, state)
+
+      case dot @ EODot(_, state) if hasSelfAsSource(dot) =>
+        processDot(dot, state)
+    }
+  }
+
+  def detectStateAccesses(
+    tree: Map[EONamedBnd, Inliner.CompleteObjectTree]
+  )(obj: (EONamedBnd, Inliner.CompleteObjectTree)): List[String] = {
+    val availableParentStates =
+      accumulateParentState(tree)(obj._2.info.parentInfo)
+    val accessedStates = obj._2.info.methods.flatMap(getAccessedStates)
+    val results =
+      for {
+        StateChange(targetMethod, state, accessedStatePath) <- accessedStates
+        State(baseClass, statePath, changedStates) <- availableParentStates
+      } yield
+        if (changedStates.contains(state) && statePath == accessedStatePath) {
+          val objName = obj._2.info.fqn.names.toList.mkString(".")
+          val stateName = state.name.name
+          val method = targetMethod.name.name
+          val container = statePath.prepended(baseClass).mkString(".")
+
+          List(
+            f"Method '$method' of object '$objName' directly accesses state '$stateName' of base class '$container'"
+          )
+        } else List()
+
+    results.toList.flatten
+  }
+
+  def analyze[F[_]](
+    originalTree: Map[EONamedBnd, Inliner.CompleteObjectTree]
+  ): EitherNel[String, List[String]] = {
+    def helper(
+      tree: Map[EONamedBnd, Inliner.CompleteObjectTree]
+    ): List[String] =
+      tree
+        .filter(_._2.info.parentInfo.nonEmpty)
+        .flatMap(detectStateAccesses(originalTree))
+        .toList
+
+    def recurse(
+      tree: Map[EONamedBnd, Inliner.CompleteObjectTree]
+    ): List[String] = {
+      val currentRes = helper(tree)
+      val children = tree.values.map(_.children)
+
+      currentRes ++ children.flatMap(recurse)
+    }
+
+    Right(recurse(originalTree))
+  }
+
+}