Creating a Custom Lint Rule for Code Quality Enforcement in Flutter

Introduction

Maintaining consistent code style and catching anti-patterns early in a Flutter project can significantly improve code quality and developer productivity. Dart’s analyzer and the linter framework allow teams to enforce custom rules that align with mobile development best practices. In this tutorial, you will learn how to create a custom lint package, define a rule to catch common issues, write tests for verify enforcement, and integrate the package into a Flutter project.

Setting Up the Lint Package

A custom lint rule lives in its own Dart package. Start by creating a new package named my_flutter_lints:

flutter create --template=package --pub my_flutter_lints

Open pubspec.yaml and add dependencies: analyzer, cli_util, and linter:

dependencies:
  analyzer: ^6.0.0
  linter

Create lib/src/rules.dart and export rule files. Then implement a Plugin class in lib/my_flutter_lints.dart:

import 'package:analyzer/plugin/plugin.dart';
import 'src/rules.dart';

class MyFlutterLintsPlugin extends ServerPlugin {
  @override
  List<LintRule> getLintRules() => allLintRules;
}

Update analyzer_plugins in pubspec.yaml to point at your plugin class.

Defining a Custom Rule

Rules extend LintRule and implement registration logic. Suppose we want to flag methods whose names start with get but don’t return a value. In lib/src/rules/getter_without_return.dart:

import 'package:analyzer/dart/ast/ast.dart';
import 'package:linter/linter.dart';

class GetterWithoutReturn extends LintRule implements NodeLintRule {
  GetterWithoutReturn()
      : super(
          name: 'getter_without_return',
          description: 'Methods starting with get must return a value.',
          group: Group.style);

  @override
  void registerNodeProcessors(NodeLintRegistry registry, LinterContext context) {
    registry.addMethodDeclaration(this, MyVisitor(this));
  }
}

class MyVisitor extends SimpleAstVisitor<void> {
  final LintRule rule;
  MyVisitor(this.rule);

  @override
  void visitMethodDeclaration(MethodDeclaration node) {
    if (node.name.name.startsWith('get') && node.returnType == null) {
      rule.reportLint(node.name);
    }
  }
}

Add GetterWithoutReturn() to allLintRules in rules.dart.

Writing Tests for the Rule

Testing ensures your rule triggers correctly. Create test/getter_without_return_test.dart. Use package:test and package:linter utilities:

import 'package:linter/src/analyzer.dart';
import 'package:test/test.dart';

import '../lib/src/rules/getter_without_return.dart';

void main() {
  final rule = GetterWithoutReturn();

  test('flags getter without return', () async {
    final source = 'class A { void getValue() {} }';
    final report = await _analyze(source, rule);
    expect(report.lints, isNotEmpty);
  });
}

Implement _analyze helper to drive the analyzer. Verify zero lints when a return type is declared.

Publishing and Integrating the Lint

Once tests pass, publish your package to pub.dev, or host it in a Git repository. To integrate into a Flutter project, add to analysis_options.yaml:

include: package:my_flutter_lints/analysis_options.yaml
linter:
  rules

Run flutter analyze to see violations. Share the lint config across team projects to maintain consistent code quality across all mobile development initiatives.

Vibe Studio

Vibe Studio, powered by Steve’s advanced AI agents, is a revolutionary no-code, conversational platform that empowers users to quickly and efficiently create full-stack Flutter applications integrated seamlessly with Firebase backend services. Ideal for solo founders, startups, and agile engineering teams, Vibe Studio allows users to visually manage and deploy Flutter apps, greatly accelerating the development process. The intuitive conversational interface simplifies complex development tasks, making app creation accessible even for non-coders.

Conclusion

Creating custom lint rules in Flutter enforces project-specific standards and reduces code review overhead. By structuring your rule as a standalone package, defining clear diagnostics, writing automated tests, and integrating via analysis_options.yaml, you elevate code quality and catch issues early in the development cycle. Custom linters are a powerful tool in any Flutter mobile development pipeline.