Supported Lint Rules

This list is auto-generated from our sources.

Rules are organized into familiar rule groups.

• errors -

  Possible coding errors.

• style -

  Matters of style, largely derived from the official Dart Style Guide.

• pub -

  Pub-related rules.

In addition, rules can be further distinguished by maturity. Unqualified rules are considered stable, while others may be marked experimental to indicate that they are under review. Lints that are marked as deprecated should not be used and are subject to removal in future Linter releases.

Rules can be selectively enabled in the analyzer using analysis options or through an analysis options file.

• An auto-generated list enabling all options is provided here.

As some lints may contradict each other, only a subset of these will be enabled in practice, but this list should provide a convenient jumping-off point.

Many lints are included in various predefined rulesets:

• core for official "core" Dart team lint rules.
• recommended for additional lint rules "recommended" by the Dart team.
• flutter for rules recommended for Flutter projects (flutter create enables these by default).

Rules included in these rulesets are badged in the documentation below.

These rules are under active development. Feedback is welcome!

Error Rules

Avoid relative imports for files in lib/.

Avoid method calls or property accesses on a "dynamic" target.

Avoid empty else statements.

Avoid print calls in production code.

Avoid relative imports for files in lib/.

Avoid returning null for Future.

Avoid slow async dart:io methods.

Avoid .toString() in production code since results may be minified.

Avoid types as parameter names.

Avoid using web-only libraries outside Flutter web plugin packages.

Cancel instances of dart.async.StreamSubscription.

Close instances of dart.core.Sink.

Invocation of various collection methods with arguments of unrelated types.

Only reference in scope identifiers in doc comments.

Avoid control flow in finally blocks.

Avoid using deprecated elements from within the package in which they are declared.

DO reference all public properties in debug methods.

Don't invoke asynchronous functions in non-async blocks.

Avoid empty statements.

Always override hashCode if overriding ==.

Don't implicitly reopen classes.

Use case expressions that are valid in Dart 3.0.

Conditions should not unconditionally evaluate to true or to false.

Invocation of Iterable.contains with references of unrelated types.

Invocation of remove with references of unrelated types.

Boolean expression composed only with literals.

Don't use adjacent strings in list.

Don't use more than one case with same value.

Don't put any logic in createState.

Prefer relative imports for files in lib/.

Don't use the Null type, unless you are positive that you don't want void.

Test type arguments in operator ==(Object other).

Avoid throw in finally block.

Avoid using unnecessary statements.

Equality operator == invocation with references of unrelated types.

Avoid unsafe HTML APIs.

Do not use BuildContexts across async gaps.

Use key in widget constructors.

Use valid regular expression syntax.

Style Rules

Declare method return types.

Separate the control structure expression from its statement.

Put required named parameters first.

Specify @required on named parameters without defaults.

Specify type annotations.

Annotate overridden members.

Avoid annotating with dynamic when not required.

Avoid using as.

Avoid bool literals in conditional expressions.

Avoid catches without on clauses.

Don't explicitly catch Error or types that implement it.

Avoid defining a class that contains only static members.

Avoid double and int checks.

Avoid overloading operator == and hashCode on classes not marked @immutable.

Avoid escaping inner quotes by converting surrounding quotes.

Avoid field initializers in const classes.

Avoid final for parameter declarations.

Avoid using forEach with a function literal.

Don't implement classes that override ==.

Don't explicitly initialize variables to null.

Avoid JavaScript rounded ints.

Don't declare multiple variables on a single line.

Don't check for null in custom == operators.

Avoid positional boolean parameters.

Avoid private typedef functions.

Avoid redundant argument values.

Don't rename parameters of overridden methods.

Avoid return types on setters.

Avoid returning null from members whose return type is bool, double, int, or num.

Avoid returning null for void.

Avoid returning this from methods just to enable a fluent interface.

Avoid setters without getters.

Avoid shadowing type parameters.

Avoid single cascade in expression statements.

Avoid annotating types for function expression parameters.

Avoid unnecessary containers.

Avoid defining unused parameters in constructors.

Avoid async functions that return void.

Await only futures.

Name extensions using UpperCamelCase.

Name types using UpperCamelCase.

Cascade consecutive method invocations on the same reference.

Don't cast a nullable value to a non nullable type.

Sort combinator names alphabetically.

Missing conditional import.

Prefer using lowerCamelCase for constant names.

DO use curly braces for all flow control structures.

Attach library doc comments to library directives.

Missing deprecated annotation.

Adhere to Effective Dart Guide directives sorting conventions.

Do not use environment declared variables.

Avoid empty catch blocks.

Use ; instead of {} for empty constructor bodies.

Do use sound null safety.

Put a single newline at end of file.

Define case clauses for all constants in enum-like classes.

Name source files using lowercase_with_underscores.

Use Flutter TODO format: // TODO(username): message, https://URL-to-issue.

Don't import implementation files from another package.

Explicitly tear-off call methods when using an object as a Function.

Join return statement with assignment when possible.

Start multiline strings with a newline.

Attach library annotations to library directives.

Name libraries using lowercase_with_underscores.

Use lowercase_with_underscores when specifying a library prefix.

Avoid using private types in public APIs.

Avoid lines longer than 80 characters.

Missing whitespace between adjacent strings.

No default cases.

Avoid leading underscores for library prefixes.

Avoid leading underscores for local identifiers.

Avoid calling toString() on runtimeType.

Name non-constant identifiers using lowerCamelCase.

Noop primitive operations.

Don't use null check on a potentially nullable type parameter.

Do not pass null as an argument where a closure is expected.

Omit type annotations for local variables.

Avoid defining a one-member abstract class when a simple function will do.

Only throw instances of classes extending either Exception or Error.

Don't override fields.

Provide doc comments for all public APIs.

Prefix library names with the package name and a dot-separated path.

Don't reassign references to parameters of functions or methods.

Use adjacent strings to concatenate string literals.

Prefer putting asserts in initializer lists.

Prefer asserts with message.

Prefer using a boolean as the assert condition.

Use collection literals when possible.

Prefer using ??= over testing for null.

Prefer const with constant constructors.

Prefer declaring const constructors on @immutable classes.

Prefer const over final for declarations.

Prefer const literals as parameters of constructors on @immutable classes.

Prefer defining constructors instead of static methods to create instances.

Use contains for List and String instances.

Prefer double quotes where they won't require escape sequences.

Use = to separate a named parameter from its default value.

Use => for short members whose body is a single return statement.

Private field could be final.

Prefer final in for-each loop variable if reference is not reassigned.

Prefer final for variable declarations if they are not reassigned.

Prefer final for parameter declarations if they are not reassigned.

Prefer 'for' elements when building maps from iterables.

Use forEach to only apply a function to all the elements.

Use a function declaration to bind a function to a name.

Prefer generic function type aliases.

Prefer if elements to conditional expressions where possible.

Prefer using if null operators.

Use initializing formals when possible.

Inline list item declarations where possible.

Prefer int literals over double literals.

Use interpolation to compose strings and values.

Use isEmpty for Iterables and Maps.

Use isNotEmpty for Iterables and Maps.

Prefer is! operator.

Prefer to use whereType on iterable.

Prefer using mixins.

Prefer null aware method calls.

Prefer using null aware operators.

Only use double quotes for strings containing single quotes.

Use spread collections when possible.

Prefer typing uninitialized variables and fields.

Provide a deprecation message, via @Deprecated("message").

Document all public members.

Property getter recursively returns itself.

Use trailing commas for all function calls and declarations.

SizedBox for whitespace.

Use SizedBox shrink and expand named constructors.

Prefer using /// for doc comments.

Sort child properties last in widget instance creations.

Sort constructor declarations before other members.

Sort unnamed constructor declarations first.

Place the super call last in a constructor initialization list.

Tighten type of initializing formal.

Type annotate public APIs.

Don't type annotate initializing formals.

Don't use constant patterns with type literals.

Future results in async function bodies must be awaited or marked unawaited using dart:async.

Unnecessary await keyword in return.

Avoid using braces in interpolation when not needed.

Don't use explicit breaks when a break is implied.

Avoid const keyword.

Unnecessary .new constructor name.

Don't use final for local variables.

Avoid wrapping fields in getters and setters just to be "safe".

Don't create a lambda when a tear-off will do.

Don't specify the late modifier when it is not needed.

Avoid library directives unless they have documentation comments or annotations.

Unnecessary new keyword.

Avoid null in null-aware assignment.

Unnecessary null aware operator on extension on a nullable type.

Unnecessary null checks.

Avoid using null in if null operators.

Use a non-nullable type for a final variable initialized with a non-nullable value.

Don't override a method to do a super method invocation with the same parameters.

Unnecessary parentheses can be removed.

Unnecessary raw string.

Remove unnecessary backslashes in strings.

Unnecessary string interpolation.

Don't access members with this unless avoiding shadowing.

Unnecessary toList() in spreads.

Unreachable top-level members in executable libraries.

Use ColoredBox.

Use DecoratedBox.

Use enums rather than classes that behave like enums.

Prefer an 8-digit hexadecimal integer(0xFFFFFFFF) to instantiate Color.

Use generic function type syntax for parameters.

Use if-null operators to convert nulls to bools.

Prefer intValue.isOdd/isEven instead of checking the result of % 2.

Use late for private members with a non-nullable type.

Use predefined named constants.

Use raw string to avoid escapes.

Use rethrow to rethrow a caught exception.

Use a setter for operations that conceptually change a property.

Use string buffers to compose strings.

Use string in part of directives.

Use super-initializer parameters where possible.

Use throwsA matcher instead of fail().

Start the name of the method with to/_to or as/_as if applicable.

Don't assign to void.

Pub Rules

Depend on referenced packages.

Use lowercase_with_underscores for package names.

Use secure urls in pubspec.yaml.

Sort pub dependencies alphabetically.