// BUG
Future<void> save() async {
  await api.save();
  Navigator.pop(context);  // widget may be unmounted
}

// FIX
Future<void> save() async {
  await api.save();
  if (!mounted) return;
  Navigator.pop(context);
}

// BUG
@override
void initState() {
  super.initState();
  final theme = Theme.of(context);  // returns a value, but no subscription
}

// FIX: move dependencies on outer data into didChangeDependencies
@override
void didChangeDependencies() {
  super.didChangeDependencies();
  final theme = Theme.of(context);
}

// FIX: use a page-level context, or a GlobalKey<NavigatorState>
final scaffoldKey = GlobalKey<ScaffoldMessengerState>();
MaterialApp(scaffoldMessengerKey: scaffoldKey, ...);

// Trigger from anywhere:
scaffoldKey.currentState?.showSnackBar(SnackBar(content: Text('done')));

// BUG
Timer.periodic(Duration(seconds: 1), (_) {
  setState(() => count++);  // still fires after the widget is disposed
});

// FIX 1: cancel in dispose
late final Timer _timer;
@override
void initState() {
  super.initState();
  _timer = Timer.periodic(Duration(seconds: 1), (_) {
    if (mounted) setState(() => count++);
  });
}
@override
void dispose() {
  _timer.cancel();
  super.dispose();
}

// BUG
@override
Widget build(BuildContext context) {
  if (data == null) {
    setState(() => data = compute());  // wrong
  }
  return Text(data ?? '');
}

// FIX: do async work in initState; if you must defer, schedule for next frame
WidgetsBinding.instance.addPostFrameCallback((_) {
  if (mounted) setState(() => data = compute());
});

// BUG
setState(() {
  result = heavyCompute();  // blocks the UI
});

// FIX
final r = await compute(heavyCompute, input);  // run in an isolate
if (mounted) setState(() => result = r);

class _MyState extends State<MyWidget> {
  final _controller = TextEditingController();
  @override
  void dispose() {
    _controller.dispose();
    super.dispose();
  }
}

late final StreamSubscription _sub;

@override
void initState() {
  super.initState();
  _sub = stream.listen((event) => ...);
}

@override
void dispose() {
  _sub.cancel();
  super.dispose();
}

// FIX 1: shrinkWrap + NeverScrollableScrollPhysics on the inner ListView
ListView(
  shrinkWrap: true,
  physics: const NeverScrollableScrollPhysics(),
  children: [...],
)

// FIX 2 (recommended): use CustomScrollView + Sliver composition
CustomScrollView(slivers: [SliverList(...), SliverGrid(...)])

// BUG
ListView(children: items.map((e) => Tile(e)).toList())

// FIX
ListView.builder(
  itemCount: items.length,
  itemBuilder: (_, i) => Tile(items[i]),
)

// FIX: cap the decode size
Image.network(
  url,
  cacheWidth: 800,   // scale during decode to save memory
  cacheHeight: 600,
)

// Or use ResizeImage
Image(image: ResizeImage(NetworkImage(url), width: 800))

// FIX: wrap the form in a SingleChildScrollView
Scaffold(
  body: SingleChildScrollView(
    padding: EdgeInsets.only(
      bottom: MediaQuery.of(context).viewInsets.bottom,
    ),
    child: Column(children: [TextField(), TextField()]),
  ),
)

// BUG
@override
Widget build(BuildContext context) {
  return FutureBuilder(
    future: api.fetch(),  // new request on every rebuild
    builder: ...,
  );
}

// FIX: cache the Future in State
late final Future<Data> _future = api.fetch();
@override
Widget build(BuildContext context) {
  return FutureBuilder(future: _future, builder: ...);
}

// BUG: silent failure
Future<void> save() async {
  try {
    await api.save();
  } catch (e) {
    // not logged, not reported, user not notified
  }
}

// FIX
try {
  await api.save();
} catch (e, st) {
  log('save failed', error: e, stackTrace: st);
  Sentry.captureException(e, stackTrace: st);
  if (mounted) showError(context, e);
  rethrow;  // or skip rethrow, but be deliberate
}

class Item {
  final int id;
  Item(this.id);

  @override
  bool operator ==(Object other) => other is Item && other.id == id;

  @override
  int get hashCode => id.hashCode;  // mandatory!
}

// `final` prevents reassignment, but the list itself is still mutable
final items = [1, 2, 3];
items.add(4);                 // works

// A `const` literal is canonicalized and deeply immutable
final items = const [1, 2, 3];
items.add(4);                 // throws UnsupportedError

// BUG: caller does not actually wait for the inner Future
Future<void> save() async {
  api.save();  // no await! caller assumes save is done
}

// FIX
Future<void> save() async {
  await api.save();
}