Check cycles on package level

Author: debs-sifive

acyclic/src-2/acyclic/plugin/Plugin.scala

@@ -10,20 +10,24 @@ class TestPlugin(val global: Global, cycleReporter: Seq[(Value, SortedSet[Int])]
   val name = "acyclic"
 
   var force = false
+  var forcePkg = false
   var fatal = true
 
   // Yeah processOptions is deprecated but keep using it anyway for 2.10.x compatibility
   override def processOptions(options: List[String], error: String => Unit): Unit = {
     if (options.contains("force")) {
       force = true
     }
+    if (options.contains("forcePkg")) {
+      forcePkg = true
+    }
     if (options.contains("warn")) {
       fatal = false
     }
   }
   val description = "Allows the developer to prohibit inter-file dependencies"
 
   val components = List[tools.nsc.plugins.PluginComponent](
-    new PluginPhase(this.global, cycleReporter, force, fatal)
+    new PluginPhase(this.global, cycleReporter, force, forcePkg, fatal)
   )
 }

acyclic/src-2/acyclic/plugin/PluginPhase.scala

@@ -19,6 +19,7 @@ class PluginPhase(
     val global: Global,
     cycleReporter: Seq[(Value, SortedSet[Int])] => Unit,
     force: => Boolean,
+    forcePkg: => Boolean,
     fatal: => Boolean
 ) extends PluginComponent { t =>
 
@@ -33,6 +34,7 @@ class PluginPhase(
   private object base extends BasePluginPhase[CompilationUnit, Tree, Symbol] with GraphAnalysis[Tree] {
     protected val cycleReporter = t.cycleReporter
     protected lazy val force = t.force
+    protected lazy val forcePkg = t.forcePkg
     protected lazy val fatal = t.fatal
 
     def treeLine(tree: Tree): Int = tree.pos.line
@@ -50,6 +52,8 @@ class PluginPhase(
       unit.body.collect { case x: PackageDef => x.pid.toString }.flatMap(_.split('.'))
     def findPkgObjects(tree: Tree): List[Tree] = tree.collect { case x: ModuleDef if x.name.toString == "package" => x }
     def pkgObjectName(pkgObject: Tree): String = pkgObject.symbol.enclosingPackageClass.fullName
+    def findPkgs(tree: Tree): List[Tree] = tree.collect { case x: PackageDef if x.symbol.fullName != "<empty>" => x }
+    def pkgName(pkg: Tree): String = pkg.symbol.fullName
     def hasAcyclicImport(tree: Tree, selector: String): Boolean =
       tree.collect {
         case Import(expr, List(sel)) => expr.symbol.toString == "package acyclic" && sel.name.toString == selector

acyclic/src-3/acyclic/plugin/Plugin.scala

@@ -12,6 +12,7 @@ class TestPlugin(cycleReporter: Seq[(Value, SortedSet[Int])] => Unit = _ => ())
   val description = "Allows the developer to prohibit inter-file dependencies"
 
   var force = false
+  var forcePkg = false
   var fatal = true
   var alreadyRun = false
 
@@ -22,7 +23,7 @@ class TestPlugin(cycleReporter: Seq[(Value, SortedSet[Int])] => Unit = _ => ())
     override def run(using Context): Unit = {
       if (!alreadyRun) {
         alreadyRun = true
-        new acyclic.plugin.PluginPhase(cycleReporter, force, fatal).run()
+        new acyclic.plugin.PluginPhase(cycleReporter, force, forcePkg, fatal).run()
       }
     }
   }
@@ -31,6 +32,9 @@ class TestPlugin(cycleReporter: Seq[(Value, SortedSet[Int])] => Unit = _ => ())
     if (options.contains("force")) {
       force = true
     }
+    if (options.contains("forcePkg")) {
+      forcePkg = true
+    }
     if (options.contains("warn")) {
       fatal = false
     }

acyclic/src-3/acyclic/plugin/PluginPhase.scala

@@ -7,6 +7,7 @@ import dotty.tools.dotc.{CompilationUnit, report}
 import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.Symbols.{NoSymbol, Symbol}
 import dotty.tools.dotc.util.NoSource
+import dotty.tools.dotc.core.Flags.Package
 
 /**
  * - Break dependency graph into strongly connected components
@@ -20,6 +21,7 @@ import dotty.tools.dotc.util.NoSource
 class PluginPhase(
   protected val cycleReporter: Seq[(Value, SortedSet[Int])] => Unit,
   protected val force: Boolean,
+  protected val forcePkg: Boolean,
   protected val fatal: Boolean
 )(using ctx: Context) extends BasePluginPhase[CompilationUnit, tpd.Tree, Symbol], GraphAnalysis[tpd.Tree] {
 
@@ -53,6 +55,14 @@ class PluginPhase(
       )
   }
 
+  private val pkgAccumulator = new tpd.TreeAccumulator[List[tpd.Tree]] {
+    def apply(acc: List[tpd.Tree], tree: tpd.Tree)(using Context): List[tpd.Tree] =
+      foldOver(
+        if (tree.symbol.is(Package) && tree.symbol.fullName.toString != "<empty>") tree :: acc else acc,
+        tree
+      )
+  }
+
   private def hasAcyclicImportAccumulator(selector: String) = new tpd.TreeAccumulator[Boolean] {
     def apply(acc: Boolean, tree: tpd.Tree)(using Context): Boolean = tree match {
       case tpd.Import(expr, List(sel)) =>
@@ -71,6 +81,8 @@ class PluginPhase(
   def unitPkgName(unit: CompilationUnit): List[String] = pkgNameAccumulator(Nil, unit.tpdTree).reverse.flatMap(_.split('.'))
   def findPkgObjects(tree: tpd.Tree): List[tpd.Tree] = pkgObjectAccumulator(Nil, tree).reverse
   def pkgObjectName(pkgObject: tpd.Tree): String = pkgObject.symbol.enclosingPackageClass.fullName.toString
+  def findPkgs(tree: tpd.Tree): List[tpd.Tree] = pkgAccumulator(Nil, tree).reverse
+  def pkgName(pkg: tpd.Tree): String = pkg.symbol.fullName.toString
   def hasAcyclicImport(tree: tpd.Tree, selector: String): Boolean = hasAcyclicImportAccumulator(selector)(false, tree)
 
   def extractDependencies(unit: CompilationUnit): Seq[(Symbol, tpd.Tree)] = DependencyExtraction(unit)

acyclic/src/acyclic/plugin/BasePluginPhase.scala

@@ -6,6 +6,7 @@ import scala.collection.{mutable, SortedSet}
 trait BasePluginPhase[CompilationUnit, Tree, Symbol] { self: GraphAnalysis[Tree] =>
   protected val cycleReporter: Seq[(Value, SortedSet[Int])] => Unit
   protected def force: Boolean
+  protected def forcePkg: Boolean
   protected def fatal: Boolean
 
   def treeLine(tree: Tree): Int
@@ -22,6 +23,8 @@ trait BasePluginPhase[CompilationUnit, Tree, Symbol] { self: GraphAnalysis[Tree]
   def unitPkgName(unit: CompilationUnit): List[String]
   def findPkgObjects(tree: Tree): List[Tree]
   def pkgObjectName(pkgObject: Tree): String
+  def findPkgs(tree: Tree): List[Tree]
+  def pkgName(tree: Tree): String
   def hasAcyclicImport(tree: Tree, selector: String): Boolean
 
   def extractDependencies(unit: CompilationUnit): Seq[(Symbol, Tree)]
@@ -39,15 +42,22 @@ trait BasePluginPhase[CompilationUnit, Tree, Symbol] { self: GraphAnalysis[Tree]
     } yield {
       Value.File(unitPath(unit), unitPkgName(unit))
     }
-
-    val acyclicPkgNames = for {
-      unit <- units
-      pkgObject <- findPkgObjects(unitTree(unit))
-      if hasAcyclicImport(pkgObject, "pkg")
-    } yield Value.Pkg(pkgObjectName(pkgObject).split('.').toList)
+    val stdPackages = if (forcePkg) packages else Seq.empty[Value.Pkg]
+    val acyclicPkgNames = packageObjects ++ stdPackages
     (skipNodePaths, acyclicNodePaths, acyclicPkgNames)
   }
 
+  private def packageObjects = for {
+    unit <- units
+    pkgObject <- findPkgObjects(unitTree(unit))
+    if hasAcyclicImport(pkgObject, "pkg")
+  } yield Value.Pkg(pkgObjectName(pkgObject).split('.').toList)
+
+  private def packages: Seq[Value.Pkg] = for {
+    unit <- units
+    pkgs <- findPkgs(unitTree(unit))
+  } yield Value.Pkg(pkgName(pkgs).split('.').toList)
+
   final def runAllUnits(): Unit = {
     val unitMap = units.map(u => unitPath(u) -> u).toMap
     val nodes = for (unit <- units) yield {

acyclic/test/resources/forcepkg/cyclicpackage/a/A1.scala

@@ -0,0 +1,6 @@
+package forcepkg.cyclicpackage
+package a
+
+class A1 extends b.B1{
+
+}

acyclic/test/resources/forcepkg/cyclicpackage/a/A2.scala

@@ -0,0 +1,5 @@
+package forcepkg.cyclicpackage.a
+
+class A2 {
+
+}

acyclic/test/resources/forcepkg/cyclicpackage/b/B1.scala

@@ -0,0 +1,3 @@
+package forcepkg.cyclicpackage.b
+
+class B1

acyclic/test/resources/forcepkg/cyclicpackage/b/B2.scala

@@ -0,0 +1,4 @@
+package forcepkg.cyclicpackage
+package b
+
+class B2 extends a.A2

acyclic/test/resources/forcepkg/simple/A.scala

@@ -0,0 +1,6 @@
+package forcepkg.simple
+
+
+class A {
+  val b: B = null
+}