fix suppressing findings within the AGP DSL

fixes #710

Author: RBusarow

modulecheck-core/src/test/kotlin/modulecheck/core/DisableViewBindingTest.kt

@@ -452,6 +452,44 @@ class DisableViewBindingTest : RunnerTest() {
     logger.parsedReport() shouldBe listOf()
   }
 
+  @Test
+  fun `unused ViewBinding should pass if suppressed`() {
+
+    val lib1 = androidLibrary(":lib1", "com.modulecheck.lib1") {
+      buildFile {
+        """
+        plugins {
+          id("com.android.library")
+          kotlin("android")
+        }
+
+        android {
+          @Suppress("disable-view-binding")
+          buildFeatures.viewBinding = true
+        }
+        """
+      }
+    }
+
+    run(
+      autoCorrect = false
+    ).isSuccess shouldBe true
+
+    lib1.buildFile shouldHaveText """
+      plugins {
+        id("com.android.library")
+        kotlin("android")
+      }
+
+      android {
+        @Suppress("disable-view-binding")
+        buildFeatures.viewBinding = true
+      }
+    """
+
+    logger.parsedReport() shouldBe listOf()
+  }
+
   @Test
   fun `unused ViewBinding without auto-correct should fail`() {
 

modulecheck-finding/api/src/main/kotlin/modulecheck/finding/Problem.kt

@@ -24,9 +24,14 @@ interface Problem :
   Finding,
   DependencyFinding {
 
+  /**
+   * Whether this Problem should be ignored. True if the associated statement is annotated with
+   * `@Suppress` and the corresponding finding ID.
+   */
   val isSuppressed: LazyDeferred<Boolean>
     get() = lazyDeferred {
-      statementOrNull.await()?.suppressed
+      statementOrNull.await()
+        ?.suppressed
         ?.contains(findingName.id)
         ?: false
     }

modulecheck-finding/impl-android/src/main/kotlin/modulecheck/finding/android/DisableViewBindingGenerationFinding.kt

@@ -33,25 +33,26 @@ import org.jetbrains.kotlin.util.suffixIfNot
 import java.io.File
 
 data class DisableViewBindingGenerationFinding(
-  override val findingName: FindingName,
   override val dependentProject: McProject,
   override val dependentPath: ProjectPath.StringProjectPath,
   override val buildFile: File
 ) : Finding, Fixable {
 
+  override val findingName = NAME
+
   override val message: String
     get() = "Android viewBinding generation is enabled, but no generated code is being used."
 
   override val dependencyIdentifier = ""
 
-  override val statementOrNull: LazyDeferred<BuildFileStatement?> = lazyDeferred { null }
-
-  override val statementTextOrNull: LazyDeferred<String?> = lazyDeferred {
-
+  override val statementOrNull: LazyDeferred<BuildFileStatement?> = lazyDeferred {
     dependentProject.buildFileParser.androidSettings()
       .assignments
       .firstOrNull { it.propertyFullName == "viewBinding" }
-      ?.declarationText
+  }
+
+  override val statementTextOrNull: LazyDeferred<String?> = lazyDeferred {
+    statementOrNull.await()?.declarationText
   }
 
   override val positionOrNull: LazyDeferred<Position?> = lazyDeferred {
@@ -139,4 +140,9 @@ data class DisableViewBindingGenerationFinding(
 
     return buildFile.readText().replace(fullText, newBlockText)
   }
+
+  companion object {
+    /** @suppress */
+    val NAME = FindingName("disable-view-binding")
+  }
 }

modulecheck-finding/impl-android/src/main/kotlin/modulecheck/finding/android/UnusedResourcesGenerationFinding.kt

@@ -44,14 +44,14 @@ data class UnusedResourcesGenerationFinding(
 
   override val dependencyIdentifier = ""
 
-  override val statementOrNull: LazyDeferred<BuildFileStatement?> = lazyDeferred { null }
-
-  override val statementTextOrNull = lazyDeferred {
-
+  override val statementOrNull: LazyDeferred<BuildFileStatement?> = lazyDeferred {
     dependentProject.buildFileParser.androidSettings()
       .assignments
       .firstOrNull { it.propertyFullName == "androidResources" }
-      ?.declarationText
+  }
+
+  override val statementTextOrNull = lazyDeferred {
+    statementOrNull.await()?.declarationText
   }
 
   override val positionOrNull: LazyDeferred<Position?> = lazyDeferred {

modulecheck-parsing/gradle/dsl/api/src/main/kotlin/modulecheck/parsing/gradle/dsl/AndroidGradleSettings.kt

@@ -27,13 +27,15 @@ data class AndroidGradleSettings(
     data class AndroidBlock(
       override val fullText: String,
       override val lambdaContent: String,
-      override val settings: List<Assignment>
+      override val settings: List<Assignment>,
+      override val blockSuppressed: List<String>
     ) : AgpBlock
 
     data class BuildFeaturesBlock(
       override val fullText: String,
       override val lambdaContent: String,
-      override val settings: List<Assignment>
+      override val settings: List<Assignment>,
+      override val blockSuppressed: List<String>
     ) : AgpBlock
   }
 }

modulecheck-parsing/gradle/dsl/api/src/main/kotlin/modulecheck/parsing/gradle/dsl/Assignment.kt

@@ -21,5 +21,5 @@ data class Assignment(
   val value: String,
   override val declarationText: String,
   override val statementWithSurroundingText: String = declarationText,
-  override val suppressed: List<String> = emptyList()
+  override val suppressed: List<String>
 ) : BuildFileStatement

modulecheck-parsing/gradle/dsl/api/src/main/kotlin/modulecheck/parsing/gradle/dsl/Block.kt

@@ -19,4 +19,7 @@ sealed interface Block<T> {
   val fullText: String
   val lambdaContent: String
   val settings: List<T>
+
+  /** [FindingNames][modulecheck.finding.FindingName] which are suppressed at the block level */
+  val blockSuppressed: List<String>
 }

modulecheck-parsing/gradle/dsl/internal/src/main/kotlin/modulecheck/parsing/gradle/dsl/internal/AbstractDependenciesBlock.kt

@@ -38,28 +38,28 @@ import modulecheck.utils.remove
 
 abstract class AbstractDependenciesBlock(
   private val logger: McLogger,
-  suppressedForEntireBlock: List<String>,
+  blockSuppressed: List<String>,
   private val configurationNameTransform: ConfigurationNameTransform,
   private val projectDependency: ProjectDependency.Factory
 ) : DependenciesBlock {
 
   private val resetManager = ResetManager()
 
-  val suppressedForEntireBlock = suppressedForEntireBlock.updateOldSuppresses()
+  final override val blockSuppressed = blockSuppressed.updateOldSuppresses()
 
   override val allSuppressions: Map<ProjectDependency, Set<FindingName>> by resetManager.lazyResets {
     buildMap<ProjectDependency, MutableSet<FindingName>> {
 
       allModuleDeclarations.forEach { (configuredModule, declarations) ->
 
         val cached = getOrPut(configuredModule) {
-          suppressedForEntireBlock.mapTo(mutableSetOf()) { FindingName(it) }
+          blockSuppressed.mapTo(mutableSetOf()) { FindingName(it) }
         }
 
         declarations.forEach { moduleDependencyDeclaration ->
 
           cached += moduleDependencyDeclaration.suppressed.updateOldSuppresses()
-            .plus(suppressedForEntireBlock)
+            .plus(blockSuppressed)
             .asFindingNames()
         }
       }
@@ -95,7 +95,7 @@ abstract class AbstractDependenciesBlock(
       moduleName = coordinates.moduleName,
       version = coordinates.version,
       coordinates = coordinates,
-      suppressed = suppressed.updateOldSuppresses() + suppressedForEntireBlock,
+      suppressed = suppressed.updateOldSuppresses() + blockSuppressed,
       configurationNameTransform = configurationNameTransform
     )
     _allDeclarations.add(declaration)
@@ -116,7 +116,7 @@ abstract class AbstractDependenciesBlock(
       configName = configName,
       declarationText = parsedString,
       statementWithSurroundingText = originalString,
-      suppressed = suppressed.updateOldSuppresses() + suppressedForEntireBlock,
+      suppressed = suppressed.updateOldSuppresses() + blockSuppressed,
       configurationNameTransform = configurationNameTransform
     )
     _allDeclarations.add(declaration)
@@ -150,7 +150,7 @@ abstract class AbstractDependenciesBlock(
       configName = configName,
       declarationText = parsedString,
       statementWithSurroundingText = originalString,
-      suppressed = suppressed.updateOldSuppresses() + suppressedForEntireBlock,
+      suppressed = suppressed.updateOldSuppresses() + blockSuppressed,
       configurationNameTransform = configurationNameTransform
     )
 

modulecheck-parsing/gradle/dsl/internal/src/main/kotlin/modulecheck/parsing/gradle/dsl/internal/AbstractPluginsBlock.kt

@@ -26,7 +26,7 @@ import java.io.File
 
 abstract class AbstractPluginsBlock(
   private val logger: McLogger,
-  suppressedForEntireBlock: List<String>
+  blockSuppressed: List<String>
 ) : PluginsBlock {
 
   private val resetManager = ResetManager()
@@ -40,19 +40,19 @@ abstract class AbstractPluginsBlock(
 
   protected val allBlockStatements = mutableListOf<String>()
 
-  private val suppressedForEntireBlock = suppressedForEntireBlock.updateOldSuppresses()
+  override val blockSuppressed = blockSuppressed.updateOldSuppresses()
 
   override val allSuppressions: Map<PluginDeclaration, Set<FindingName>> by resetManager.lazyResets {
     buildMap<PluginDeclaration, MutableSet<FindingName>> {
 
       _allDeclarations.forEach { pluginDeclaration ->
 
         val cached = getOrPut(pluginDeclaration) {
-          suppressedForEntireBlock.mapTo(mutableSetOf()) { FindingName(it) }
+          blockSuppressed.mapTo(mutableSetOf()) { FindingName(it) }
         }
 
         cached += pluginDeclaration.suppressed.updateOldSuppresses()
-          .plus(suppressedForEntireBlock)
+          .plus(blockSuppressed)
           .asFindingNames()
       }
     }
@@ -67,7 +67,7 @@ abstract class AbstractPluginsBlock(
     val declaration = PluginDeclaration(
       statementWithSurroundingText = originalString,
       declarationText = parsedString,
-      suppressed = suppressed.updateOldSuppresses() + suppressedForEntireBlock
+      suppressed = suppressed.updateOldSuppresses() + blockSuppressed
     )
     _allDeclarations.add(declaration)
     resetManager.resetAll()

modulecheck-parsing/groovy-antlr/src/main/kotlin/modulecheck/parsing/groovy/antlr/EverythingPrinter.kt

@@ -15,54 +15,53 @@
 
 package modulecheck.parsing.groovy.antlr
 
-import groovyjarjarantlr4.v4.runtime.tree.ParseTree
-import groovyjarjarantlr4.v4.runtime.tree.RuleNode
-import org.apache.groovy.parser.antlr4.GroovyParser
-import org.apache.groovy.parser.antlr4.GroovyParserBaseVisitor
+import groovyjarjarantlr4.v4.runtime.ParserRuleContext
+import groovyjarjarantlr4.v4.runtime.RuleContext
+import modulecheck.utils.requireNotNull
 
-internal class EverythingPrinter : GroovyParserBaseVisitor<Unit>() {
+internal fun ParserRuleContext.printEverything() {
 
-  private val dashes = "------------------------------------------------------------"
-
-  override fun visit(tree: ParseTree) {
-
-    val parent = tree.parent?.let { it::class.java.simpleName }
+  val levels = mutableMapOf<RuleContext, Int>(this to 0)
+  val dashes = "------------------------------------------------------------"
 
+  fun printMe(nodeSimpleName: String, parentName: String, nodeText: String, level: Int) {
     println(
-      """ $dashes  ${tree::class.java.simpleName}    -- parent: $parent
-      |
-      |`${tree.text}`
+      """
+      |   $dashes  $nodeSimpleName    -- parent: $parentName
       |
+      |   `$nodeText`
       """.trimMargin()
+        .lines()
+        .let {
+          it.dropLast(1) + it.last().replaceFirst("  ", "└─")
+        }
+        .joinToString("\n")
+        .prependIndent("│   ".repeat(level))
     )
-    super.visit(tree)
   }
 
-  override fun visitChildren(node: RuleNode) {
+  printMe(
+    nodeSimpleName = javaClass.simpleName, parentName = "null", nodeText = text, level = 0
+  )
 
-    val parent = node.parent?.let { it::class.java.simpleName }
+  childrenOfTypeRecursive<ParserRuleContext>()
+    .filterNot { it == this }
+    .forEach { node ->
 
-    println(
-      """ $dashes  ${node::class.java.simpleName}    -- parent: $parent
-      |
-      |`${node.text}`
-      |
-      """.trimMargin()
-    )
-    super.visitChildren(node)
-  }
+      val parent = node.parent.requireNotNull {
+        "Parent is null for ${node.javaClass.simpleName}, but that's impossible?"
+      }
 
-  override fun visitExpression(ctx: GroovyParser.ExpressionContext) {
+      val parentLevel = levels.getValue(parent)
+      levels[node] = parentLevel + 1
 
-    val parent = ctx.parent?.let { it::class.java.simpleName }
+      val parentName = parent.javaClass.simpleName
 
-    println(
-      """ $dashes  ${ctx::class.java.simpleName}    -- parent: $parent
-      |
-      |`${ctx.text}`
-      |
-      """.trimMargin()
-    )
-    super.visitExpression(ctx)
-  }
+      printMe(
+        nodeSimpleName = node.javaClass.simpleName,
+        parentName = parentName,
+        nodeText = node.text,
+        level = parentLevel + 1
+      )
+    }
 }