xlints

Detects widgets that can be const but are not marked const.

BAD:

Widget build(BuildContext context) {
  return Padding(
    padding: EdgeInsets.all(8),
    child: Icon(Icons.star),
  );
}

GOOD:

Widget build(BuildContext context) {
  return const Padding(
    padding: EdgeInsets.all(8),
    child: Icon(Icons.star),
  );
}

Detects long lists that should use .builder.

BAD:

ListView(
  children: List.generate(1000, (i) => Text('Item $i')),
)

GOOD:

ListView.builder(
  itemCount: 1000,
  itemBuilder: (_, i) => Text('Item $i'),
)

Detects ListView/GridView(children: ...) usage that builds all items eagerly.

BAD:

GridView(
  children: List.generate(200, (i) => Card(child: Text('$i'))),
)

GOOD:

GridView.builder(
  gridDelegate: const SliverGridDelegateWithFixedCrossAxisCount(crossAxisCount: 2),
  itemCount: 200,
  itemBuilder: (_, i) => Card(child: Text('$i')),
)

Detects Opacity usage in cases where a cheaper alternative is preferred.

BAD:

Opacity(
  opacity: 0.5,
  child: Image.network(url),
)

GOOD:

AnimatedOpacity(
  opacity: 0.5,
  duration: const Duration(milliseconds: 200),
  child: Image.network(url),
)

Detects Padding wrapping a child that already uses margin.

BAD:

Padding(
  padding: const EdgeInsets.all(16),
  child: Container(
    margin: const EdgeInsets.all(8),
    child: const Text('Hello'),
  ),
)

GOOD:

Container(
  margin: const EdgeInsets.all(24),
  child: const Text('Hello'),
)

Detects shrinkWrap: true on list/grid widgets, which can increase layout cost.

BAD:

ListView(
  shrinkWrap: true,
  children: items.map((e) => Text(e)).toList(),
)

GOOD:

Expanded(
  child: ListView.builder(
    itemCount: items.length,
    itemBuilder: (_, i) => Text(items[i]),
  ),
)

Detects expensive IntrinsicHeight/IntrinsicWidth usage.

BAD:

IntrinsicHeight(
  child: Row(children: children),
)

GOOD:

SizedBox(
  height: 72,
  child: Row(children: children),
)

Detects controller/node creation inside build().

BAD:

@override
Widget build(BuildContext context) {
  final controller = ScrollController();
  return ListView(controller: controller);
}

BAD:

@override
Widget build(BuildContext context) {
  final focusNode = FocusNode();
  return TextField(focusNode: focusNode);
}

GOOD:

class _MyState extends State<MyWidget> {
  late final ScrollController controller;

  @override
  void initState() {
    super.initState();
    controller = ScrollController();
  }

  @override
  void dispose() {
    controller.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return ListView(controller: controller);
  }
}

Detects operator == override on Widget subclasses.

BAD:

class MyCard extends StatelessWidget {
  @override
  bool operator ==(Object other) => identical(this, other);

  @override
  int get hashCode => 0;

  @override
  Widget build(BuildContext context) => const SizedBox();
}

GOOD:

class MyCard extends StatelessWidget {
  const MyCard({super.key});

  @override
  Widget build(BuildContext context) => const SizedBox();
}

Detects setState() calls inside build().

BAD:

@override
Widget build(BuildContext context) {
  setState(() => counter++);
  return Text('$counter');
}

GOOD:

void _increment() {
  setState(() => counter++);
}

Detects jsonDecode usage inside build().

BAD:

@override
Widget build(BuildContext context) {
  final data = jsonDecode(rawJson);
  return Text('${data['title']}');
}

GOOD:

late final Map<String, dynamic> data;

@override
void initState() {
  super.initState();
  data = jsonDecode(rawJson) as Map<String, dynamic>;
}

Detects heavy synchronous collection work in build().

BAD:

@override
Widget build(BuildContext context) {
  final values = items.toList()..sort();
  return Text('${values.first}');
}

GOOD:

late final List<int> sorted;

@override
void initState() {
  super.initState();
  sorted = items.toList()..sort();
}

Detects local var variables that are never reassigned.

BAD:

void logValue() {
  var message = 'ready';
  print(message);
}

GOOD:

void logValue() {
  final message = 'ready';
  print(message);
}

Detects repeated RegExp(...) creation in loops/build.

BAD:

for (final item in items) {
  final r = RegExp(r'\d+');
  if (r.hasMatch(item)) {}
}

GOOD:

final r = RegExp(r'\d+');
for (final item in items) {
  if (r.hasMatch(item)) {}
}

Detects list.contains(...) calls inside loops.

BAD:

for (final id in ids) {
  if (selectedIds.contains(id)) {}
}

GOOD:

final selectedSet = selectedIds.toSet();
for (final id in ids) {
  if (selectedSet.contains(id)) {}
}

Detects repeated DateTime.now() calls inside loops.

BAD:

for (var i = 0; i < 100; i++) {
  final now = DateTime.now();
  consume(now);
}

GOOD:

final now = DateTime.now();
for (var i = 0; i < 100; i++) {
  consume(now);
}

Detects temporary list accumulation patterns better expressed with collection literals.

BAD:

final widgets = <Widget>[];
if (showHeader) widgets.add(const Text('Header'));
if (items.isNotEmpty) widgets.addAll(items.map(Text.new));

GOOD:

final widgets = <Widget>[
  if (showHeader) const Text('Header'),
  if (items.isNotEmpty) ...items.map(Text.new),
];

Detects string concatenation with + inside loops.

BAD:

var result = '';
for (var i = 0; i < 1000; i++) {
  result = result + values[i];
}

GOOD:

final buffer = StringBuffer();
for (var i = 0; i < 1000; i++) {
  buffer.write(values[i]);
}
final result = buffer.toString();