Android Custom Lint Rules Samples

To create a custom lint rule that analyzes Kotlin or Java code, implement the Detector interface and the UastScanner interface.

1. Define applicable types: Override getApplicableUastTypes() to return a list of UAST (Unified Abstract Syntax Tree) element classes you want to inspect (e.g., ULiteralExpression::class.java).
2. Create a handler: Override createUastHandler(context: JavaContext) to return a UElementHandler. This handler contains the logic for visiting specific nodes.
3. Report issues: Inside the handler's visit methods, use context.report() to flag violations. You must provide the Issue definition, the node being inspected, the location of the issue, and a descriptive message.

Note: While UElementHandler is a general-purpose mechanism, Lint provides specialized support for common tasks like visiting classes that extend a specific superclass or method call sites. Always check UastScanner implementations and context.getJavaEvaluator() for utility functions before implementing manual UAST traversal.

class SampleCodeDetector : Detector(), UastScanner {
  override fun getApplicableUastTypes(): List<Class<out UElement?>> {
    return listOf(ULiteralExpression::class.java)
  }

  override fun createUastHandler(context: JavaContext): UElementHandler {
    return object : UElementHandler() {
      override fun visitLiteralExpression(node: ULiteralExpression) {
        val string = node.evaluateString() ?: return
        if (string.contains("lint")) {
          context.report(
            ISSUE,
            node,
            context.getLocation(node),
            "This code mentions `lint`: **Congratulations**",
          )
        }
      }
    }
  }
}

To make your custom lint rules available to the Android Lint engine, you must implement the IssueRegistry class. This registry acts as the entry point that tells Lint which issues to check.

Your implementation must override the following properties:

• issues: A list of Issue objects provided by your detectors (e.g., SampleCodeDetector.ISSUE).
• api: The current Lint API version, typically using com.android.tools.lint.detector.api.CURRENT_API.
• minApi: The minimum Lint API version required for your rules to run (e.g., 8 for Studio 4.1 or later).
• vendor (optional): A Vendor object containing metadata like vendorName, feedbackUrl, and contact for users to report issues.

import com.android.tools.lint.client.api.IssueRegistry
import com.android.tools.lint.client.api.Vendor
import com.android.tools.lint.detector.api.CURRENT_API

class SampleIssueRegistry : IssueRegistry() {
  override val issues =
    listOf(SampleCodeDetector.ISSUE, AvoidDateDetector.ISSUE, NotNullAssertionDetector.ISSUE)

  override val api: Int
    get() = CURRENT_API

  override val minApi: Int
    get() = 8

  override val vendor: Vendor =
    Vendor(
      vendorName = "Android Open Source Project",
      feedbackUrl = "https://github.com/googlesamples/android-custom-lint-rules/issues",
      contact = "https://github.com/googlesamples/android-custom-lint-rules",
    )
}

A Lint Issue defines how a problem is identified, described, and categorized in the IDE and analysis reports. It is typically defined in a companion object within your Detector class using Issue.create().

Key parameters for Issue.create():

• id: A unique string used for @SuppressLint warnings.
• briefDescription: A short title shown in IDE preference dialogs and analysis results.
• explanation: A detailed description of the issue, supporting Markdown (e.g., monospace, italic, bold).
• category: The Category of the issue (e.g., Category.CORRECTNESS).
• priority: An integer representing the importance.
• severity: The Severity level (e.g., Severity.WARNING).
• implementation: An Implementation object specifying the detector class and its Scope (e.g., Scope.JAVA_FILE_SCOPE).

@JvmField
val ISSUE: Issue =
  Issue.create(
    id = "SampleId",
    briefDescription = "Lint Mentions",
    explanation = "This check highlights string literals in code which mentions the word `lint`.",
    category = Category.CORRECTNESS,
    priority = 6,
    severity = Severity.WARNING,
    implementation = Implementation(SampleCodeDetector::class.java, Scope.JAVA_FILE_SCOPE),
  )