dart-decimate 0.0.10 → 0.0.11

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -2,106 +2,1881 @@ use std::path::Path;
2
2
 
3
3
  use super::*;
4
4
 
5
+ const STATE_FIELD_ROOT_SHADOWS_SOURCE: &str = r"
6
+ class RealStateReadPanel extends StatefulWidget {
7
+ const RealStateReadPanel({super.key, required this.title});
8
+ final String title;
9
+ State<RealStateReadPanel> createState() => _RealStateReadPanelState();
10
+ }
11
+ class _RealStateReadPanelState extends State<RealStateReadPanel> {
12
+ Widget build(BuildContext context) => Text(widget.title);
13
+ }
14
+ class DidUpdateWidgetPanel extends StatefulWidget {
15
+ const DidUpdateWidgetPanel({super.key, required this.title});
16
+ final String title;
17
+ State<DidUpdateWidgetPanel> createState() => _DidUpdateWidgetPanelState();
18
+ }
19
+ class _DidUpdateWidgetPanelState extends State<DidUpdateWidgetPanel> {
20
+ void didUpdateWidget(covariant DidUpdateWidgetPanel oldWidget) {
21
+ super.didUpdateWidget(oldWidget);
22
+ Text(oldWidget.title);
23
+ }
24
+ Widget build(BuildContext context) => const SizedBox();
25
+ }
26
+ class LocalShadowStatePanel extends StatefulWidget {
27
+ const LocalShadowStatePanel({super.key, required this.title});
28
+ final String title;
29
+ State<LocalShadowStatePanel> createState() => _LocalShadowStatePanelState();
30
+ }
31
+ class _LocalShadowStatePanelState extends State<LocalShadowStatePanel> {
32
+ Widget build(BuildContext context) {
33
+ final widget = const LocalShadowStatePanel(title: 'local');
34
+ return Text(widget.title);
35
+ }
36
+ }
37
+ class CallbackShadowStatePanel extends StatefulWidget {
38
+ const CallbackShadowStatePanel({super.key, required this.title});
39
+ final String title;
40
+ State<CallbackShadowStatePanel> createState() => _CallbackShadowStatePanelState();
41
+ }
42
+ class _CallbackShadowStatePanelState extends State<CallbackShadowStatePanel> {
43
+ Widget build(BuildContext context) {
44
+ return [const CallbackShadowStatePanel(title: 'local')]
45
+ .map((widget) => Text(widget.title))
46
+ .first;
47
+ }
48
+ }
49
+ class HeaderShadowStatePanel extends StatefulWidget {
50
+ const HeaderShadowStatePanel({super.key, required this.title});
51
+ final String title;
52
+ State<HeaderShadowStatePanel> createState() => _HeaderShadowStatePanelState();
53
+ }
54
+ class _HeaderShadowStatePanelState extends State<HeaderShadowStatePanel> {
55
+ Widget build(BuildContext context) {
56
+ for (final widget in [const HeaderShadowStatePanel(title: 'local')]) {
57
+ Text(widget.title);
58
+ }
59
+ return const SizedBox();
60
+ }
61
+ }
62
+ class PatternShadowStatePanel extends StatefulWidget {
63
+ const PatternShadowStatePanel({super.key, required this.title});
64
+ final String title;
65
+ State<PatternShadowStatePanel> createState() => _PatternShadowStatePanelState();
66
+ }
67
+ class _PatternShadowStatePanelState extends State<PatternShadowStatePanel> {
68
+ Widget build(BuildContext context) {
69
+ final record = (widget: const PatternShadowStatePanel(title: 'local'));
70
+ final (:widget) = record;
71
+ return Text(widget.title);
72
+ }
73
+ }
74
+ class CaseShadowStatePanel extends StatefulWidget {
75
+ const CaseShadowStatePanel({super.key, required this.title});
76
+ final String title;
77
+ State<CaseShadowStatePanel> createState() => _CaseShadowStatePanelState();
78
+ }
79
+ class _CaseShadowStatePanelState extends State<CaseShadowStatePanel> {
80
+ Widget build(BuildContext context) {
81
+ if ((widget: const CaseShadowStatePanel(title: 'local')) case (:final widget)) {
82
+ Text(widget.title);
83
+ }
84
+ return const SizedBox();
85
+ }
86
+ }
87
+ class OldWidgetLocalShadowPanel extends StatefulWidget {
88
+ const OldWidgetLocalShadowPanel({super.key, required this.title});
89
+ final String title;
90
+ State<OldWidgetLocalShadowPanel> createState() => _OldWidgetLocalShadowPanelState();
91
+ }
92
+ class _OldWidgetLocalShadowPanelState extends State<OldWidgetLocalShadowPanel> {
93
+ void didUpdateWidget(covariant OldWidgetLocalShadowPanel oldWidget) {
94
+ super.didUpdateWidget(oldWidget);
95
+ final oldWidget = const OldWidgetLocalShadowPanel(title: 'local');
96
+ Text(oldWidget.title);
97
+ }
98
+ Widget build(BuildContext context) => const SizedBox();
99
+ }
100
+ ";
101
+
102
+ const DIRECT_FIELD_SHADOWS_SOURCE: &str = r"
103
+ class LocalShadowCard extends StatelessWidget {
104
+ const LocalShadowCard({super.key, required this.title});
105
+ final String title;
106
+ Widget build(BuildContext context) {
107
+ const title = 'local';
108
+ return Text(title);
109
+ }
110
+ }
111
+ class ParameterShadowCard extends StatelessWidget {
112
+ const ParameterShadowCard({super.key, required this.title});
113
+ final String title;
114
+ Widget label(String title) => Text(title);
115
+ Widget build(BuildContext context) => label('local');
116
+ }
117
+ class CallbackParameterShadowCard extends StatelessWidget {
118
+ const CallbackParameterShadowCard({super.key, required this.title});
119
+ final String title;
120
+ Widget build(BuildContext context) {
121
+ return ['local'].map((title) => Text(title)).first;
122
+ }
123
+ }
124
+ class DirectFieldCard extends StatelessWidget {
125
+ const DirectFieldCard({super.key, required this.title});
126
+ final String title;
127
+ Widget build(BuildContext context) => Text(title);
128
+ }
129
+ class LaterLocalShadowCard extends StatelessWidget {
130
+ const LaterLocalShadowCard({super.key, required this.title});
131
+ final String title;
132
+ Widget build(BuildContext context) {
133
+ final child = Text(title);
134
+ const title = 'local';
135
+ return child;
136
+ }
137
+ }
138
+ class LaterCallbackShadowCard extends StatelessWidget {
139
+ const LaterCallbackShadowCard({super.key, required this.title});
140
+ final String title;
141
+ Widget build(BuildContext context) {
142
+ final child = Text(title);
143
+ ['local'].map((title) => Text(title)).toList();
144
+ return child;
145
+ }
146
+ }
147
+ class EarlierBlockShadowCard extends StatelessWidget {
148
+ const EarlierBlockShadowCard({super.key, required this.title});
149
+ final String title;
150
+ Widget build(BuildContext context) {
151
+ if (true) {
152
+ const title = 'local';
153
+ Text(title);
154
+ }
155
+ return Text(title);
156
+ }
157
+ }
158
+ class EarlierFunctionShadowCard extends StatelessWidget {
159
+ const EarlierFunctionShadowCard({super.key, required this.title});
160
+ final String title;
161
+ Widget build(BuildContext context) {
162
+ void label() {
163
+ const title = 'local';
164
+ Text(title);
165
+ }
166
+ label();
167
+ return Text(title);
168
+ }
169
+ }
170
+ class PriorCallbackShadowThenUseCard extends StatelessWidget {
171
+ const PriorCallbackShadowThenUseCard({super.key, required this.title});
172
+ final String title;
173
+ Widget build(BuildContext context) {
174
+ final labels = ['local'].map((title) => title).toList();
175
+ return Text(title);
176
+ }
177
+ }
178
+ class PriorCallbackLocalThenUseCard extends StatelessWidget {
179
+ const PriorCallbackLocalThenUseCard({super.key, required this.title});
180
+ final String title;
181
+ Widget build(BuildContext context) {
182
+ final labels = ['local'].map((value) {
183
+ final title = value;
184
+ return title;
185
+ }).toList();
186
+ return Text(title);
187
+ }
188
+ }
189
+ class ElseBranchShadowCard extends StatelessWidget {
190
+ const ElseBranchShadowCard({super.key, required this.title});
191
+ final String title;
192
+ Widget build(BuildContext context, bool useLocal) {
193
+ if (useLocal) {
194
+ const title = 'local';
195
+ return Text(title);
196
+ } else {
197
+ return Text(title);
198
+ }
199
+ }
200
+ }
201
+ class FunctionTypedSignatureShadowCard extends StatelessWidget {
202
+ const FunctionTypedSignatureShadowCard({super.key, required this.title});
203
+ final String title;
204
+ Widget build(BuildContext context, String Function(String title) format) => Text(title);
205
+ }
206
+ ";
207
+
208
+ #[test]
209
+ fn flags_unused_stateless_widget_field_formal() -> Result<(), Box<dyn std::error::Error>> {
210
+ let source = r"
211
+ class UserCard extends StatelessWidget {
212
+ const UserCard({super.key, required this.title, required this.subtitle});
213
+ final String title;
214
+ final String subtitle;
215
+ Widget build(BuildContext context) => Text(title);
216
+ }
217
+ ";
218
+ let unused = parse_findings(source)?.unused_params;
219
+
220
+ assert_eq!(unused.len(), 1);
221
+ assert_eq!(unused[0].widget_class, "UserCard");
222
+ assert_eq!(unused[0].param_name, "subtitle");
223
+ assert_eq!(unused[0].location.line, 3);
224
+ Ok(())
225
+ }
226
+
227
+ #[test]
228
+ fn flags_unused_explicit_widget_constructor_params() -> Result<(), Box<dyn std::error::Error>> {
229
+ let source = r"
230
+ class UserCard extends StatelessWidget {
231
+ const UserCard({super.key, required String unused, required String used})
232
+ : unused = unused,
233
+ used = used;
234
+ final String unused;
235
+ final String used;
236
+ Widget build(BuildContext context) => Text(used);
237
+ }
238
+ ";
239
+ let unused = parse_findings(source)?.unused_params;
240
+
241
+ assert_eq!(unused.len(), 1);
242
+ assert_eq!(unused[0].widget_class, "UserCard");
243
+ assert_eq!(unused[0].param_name, "unused");
244
+ assert_eq!(unused[0].location.line, 3);
245
+ Ok(())
246
+ }
247
+
248
+ #[test]
249
+ fn respects_explicit_params_used_through_backing_fields_and_state()
250
+ -> Result<(), Box<dyn std::error::Error>> {
251
+ let source = r"
252
+ class UserCard extends StatelessWidget {
253
+ const UserCard({super.key, required String label}) : _label = label;
254
+ final String _label;
255
+ Widget build(BuildContext context) => Text(_label);
256
+ }
257
+ class CounterCard extends StatefulWidget {
258
+ const CounterCard({super.key, required int count}) : _count = count;
259
+ final int _count;
260
+ State<CounterCard> createState() => _CounterCardState();
261
+ }
262
+ class _CounterCardState extends State<CounterCard> {
263
+ Widget build(BuildContext context) => Text('${widget._count}');
264
+ }
265
+ ";
266
+ let unused = parse_findings(source)?.unused_params;
267
+
268
+ assert!(unused.is_empty(), "{unused:?}");
269
+ Ok(())
270
+ }
271
+
272
+ #[test]
273
+ fn flags_explicit_params_when_backing_field_is_unused() -> Result<(), Box<dyn std::error::Error>> {
274
+ let source = r"
275
+ class UserCard extends StatelessWidget {
276
+ const UserCard({super.key, required String subtitle}) : _subtitle = subtitle;
277
+ final String _subtitle;
278
+ Widget build(BuildContext context) => const SizedBox();
279
+ }
280
+ ";
281
+ let unused = parse_findings(source)?.unused_params;
282
+
283
+ assert_eq!(unused.len(), 1);
284
+ assert_eq!(unused[0].param_name, "subtitle");
285
+ Ok(())
286
+ }
287
+
288
+ #[test]
289
+ fn respects_widget_and_state_usages() -> Result<(), Box<dyn std::error::Error>> {
290
+ let source = r"
291
+ class UsedInBuild extends StatelessWidget {
292
+ const UsedInBuild({super.key, required this.title});
293
+ final String title;
294
+ Widget build(BuildContext context) => Text('$title');
295
+ }
296
+ class UsedViaState extends StatefulWidget {
297
+ const UsedViaState({super.key, required this.count});
298
+ final int count;
299
+ State<UsedViaState> createState() => _UsedViaStateState();
300
+ }
301
+ class _UsedViaStateState extends State<UsedViaState> {
302
+ Widget build(BuildContext context) => Text('${widget.count}');
303
+ }
304
+ ";
305
+ let unused = parse_findings(source)?.unused_params;
306
+
307
+ assert!(unused.is_empty(), "{unused:?}");
308
+ Ok(())
309
+ }
310
+
311
+ #[test]
312
+ fn state_field_reads_ignore_widget_root_shadows() -> Result<(), Box<dyn std::error::Error>> {
313
+ let targets =
314
+ unused_param_targets(parse_findings(STATE_FIELD_ROOT_SHADOWS_SOURCE)?.unused_params);
315
+
316
+ assert_eq!(
317
+ targets,
318
+ vec![
319
+ "LocalShadowStatePanel.title",
320
+ "CallbackShadowStatePanel.title",
321
+ "HeaderShadowStatePanel.title",
322
+ "PatternShadowStatePanel.title",
323
+ "CaseShadowStatePanel.title",
324
+ "OldWidgetLocalShadowPanel.title"
325
+ ]
326
+ );
327
+ Ok(())
328
+ }
329
+
330
+ #[test]
331
+ fn direct_field_reads_ignore_local_and_parameter_shadows() -> Result<(), Box<dyn std::error::Error>>
332
+ {
333
+ let unused = parse_findings(DIRECT_FIELD_SHADOWS_SOURCE)?.unused_params;
334
+ let targets = unused
335
+ .iter()
336
+ .map(|param| format!("{}.{}", param.widget_class, param.param_name))
337
+ .collect::<Vec<_>>();
338
+
339
+ assert_eq!(
340
+ targets,
341
+ vec![
342
+ "LocalShadowCard.title",
343
+ "ParameterShadowCard.title",
344
+ "CallbackParameterShadowCard.title"
345
+ ]
346
+ );
347
+ Ok(())
348
+ }
349
+
350
+ #[test]
351
+ fn direct_field_reads_ignore_for_in_and_catch_header_shadows()
352
+ -> Result<(), Box<dyn std::error::Error>> {
353
+ let source = r"
354
+ class ForInShadowCard extends StatelessWidget {
355
+ const ForInShadowCard({super.key, required this.title});
356
+ final String title;
357
+ Widget build(BuildContext context) {
358
+ for (final title in ['local']) {
359
+ Text(title);
360
+ }
361
+ return const SizedBox();
362
+ }
363
+ }
364
+ class CatchExceptionShadowCard extends StatelessWidget {
365
+ const CatchExceptionShadowCard({super.key, required this.title});
366
+ final String title;
367
+ Widget build(BuildContext context) {
368
+ try {
369
+ throw Exception();
370
+ } catch (title) {
371
+ return Text(title);
372
+ }
373
+ return const SizedBox();
374
+ }
375
+ }
376
+ class CatchStackShadowCard extends StatelessWidget {
377
+ const CatchStackShadowCard({super.key, required this.title});
378
+ final String title;
379
+ Widget build(BuildContext context) {
380
+ try {
381
+ throw Exception();
382
+ } catch (error, title) {
383
+ return Text(title);
384
+ }
385
+ return const SizedBox();
386
+ }
387
+ }
388
+ class CatchFinallyFieldCard extends StatelessWidget {
389
+ const CatchFinallyFieldCard({super.key, required this.title});
390
+ final String title;
391
+ Widget build(BuildContext context) {
392
+ try {
393
+ throw Exception();
394
+ } catch (title) {
395
+ Text(title);
396
+ } finally {
397
+ Text(title);
398
+ }
399
+ return const SizedBox();
400
+ }
401
+ }
402
+ class DirectFieldCard extends StatelessWidget {
403
+ const DirectFieldCard({super.key, required this.title});
404
+ final String title;
405
+ Widget build(BuildContext context) => Text(title);
406
+ }
407
+ ";
408
+ let targets = unused_param_targets(parse_findings(source)?.unused_params);
409
+
410
+ assert_eq!(
411
+ targets,
412
+ vec![
413
+ "ForInShadowCard.title",
414
+ "CatchExceptionShadowCard.title",
415
+ "CatchStackShadowCard.title"
416
+ ]
417
+ );
418
+ Ok(())
419
+ }
420
+
421
+ #[test]
422
+ fn forwarded_usage_requires_exact_constructor_invocation() -> Result<(), Box<dyn std::error::Error>>
423
+ {
424
+ let source = r"
425
+ class ForwardingPanel extends StatefulWidget {
426
+ const ForwardingPanel({super.key, required this.items});
427
+ final List<String> items;
428
+ State<ForwardingPanel> createState() => _ForwardingPanelState();
429
+ }
430
+
431
+ class _ForwardingPanelState extends State<ForwardingPanel> {
432
+ Widget build(BuildContext context) {
433
+ final ignored = NotForwardedViewData.fromOwner(source: widget);
434
+ final label = 'ForwardedViewData.fromOwner(source: widget)';
435
+ return Text('$ignored $label');
436
+ }
437
+ }
438
+
439
+ class ForwardedViewData {
440
+ ForwardedViewData.fromOwner({required ForwardingPanel source})
441
+ : items = source.items;
442
+ final List<String> items;
443
+ }
444
+
445
+ class NotForwardedViewData {
446
+ NotForwardedViewData.fromOwner({required ForwardingPanel source});
447
+ }
448
+ ";
449
+ let targets = unused_param_targets(parse_findings(source)?.unused_params);
450
+
451
+ assert_eq!(targets, vec!["ForwardingPanel.items"]);
452
+ Ok(())
453
+ }
454
+
455
+ #[test]
456
+ fn forwarded_usage_ignores_nested_parameter_shadows() -> Result<(), Box<dyn std::error::Error>> {
457
+ let source = r"
458
+ class ForwardingPanel extends StatefulWidget {
459
+ const ForwardingPanel({super.key, required this.items});
460
+ final List<String> items;
461
+ State<ForwardingPanel> createState() => _ForwardingPanelState();
462
+ }
463
+
464
+ class _ForwardingPanelState extends State<ForwardingPanel> {
465
+ Widget build(BuildContext context) {
466
+ final data = ForwardedViewData.fromOwner(source: widget);
467
+ return Text(data.label);
468
+ }
469
+ }
470
+
471
+ class ForwardedViewData {
472
+ ForwardedViewData.fromOwner({required ForwardingPanel source})
473
+ : label = [const ForwardingPanel(items: ['fallback'])]
474
+ .map((source) => source.items.join(','))
475
+ .first;
476
+ final String label;
477
+ }
478
+ ";
479
+ let targets = unused_param_targets(parse_findings(source)?.unused_params);
480
+
481
+ assert_eq!(targets, vec!["ForwardingPanel.items"]);
482
+ Ok(())
483
+ }
484
+
485
+ #[test]
486
+ fn forwarded_usage_ignores_forwarder_local_shadows() -> Result<(), Box<dyn std::error::Error>> {
487
+ let source = r"
488
+ class BlockLocalForwardingPanel extends StatefulWidget {
489
+ const BlockLocalForwardingPanel({super.key, required this.items});
490
+ final List<String> items;
491
+ State<BlockLocalForwardingPanel> createState() => _BlockLocalForwardingPanelState();
492
+ }
493
+
494
+ class _BlockLocalForwardingPanelState extends State<BlockLocalForwardingPanel> {
495
+ Widget build(BuildContext context) {
496
+ final data = ForwardedViewData.fromBlockLocal(source: widget);
497
+ return Text(data.label);
498
+ }
499
+ }
500
+
501
+ class PatternLocalForwardingPanel extends StatefulWidget {
502
+ const PatternLocalForwardingPanel({super.key, required this.items});
503
+ final List<String> items;
504
+ State<PatternLocalForwardingPanel> createState() => _PatternLocalForwardingPanelState();
505
+ }
506
+
507
+ class _PatternLocalForwardingPanelState extends State<PatternLocalForwardingPanel> {
508
+ Widget build(BuildContext context) {
509
+ final data = ForwardedViewData.fromPatternLocal(source: widget);
510
+ return Text(data.label);
511
+ }
512
+ }
513
+
514
+ class ForwardedViewData {
515
+ ForwardedViewData.fromBlockLocal({required BlockLocalForwardingPanel source}) {
516
+ final local = const BlockLocalForwardingPanel(items: ['local']);
517
+ {
518
+ final source = local;
519
+ label = source.items.join(',');
520
+ }
521
+ }
522
+ ForwardedViewData.fromPatternLocal({required PatternLocalForwardingPanel source}) {
523
+ final record = (source: const PatternLocalForwardingPanel(items: ['local']));
524
+ final (:source) = record;
525
+ label = source.items.join(',');
526
+ }
527
+ late final String label;
528
+ }
529
+ ";
530
+ let targets = unused_param_targets(parse_findings(source)?.unused_params);
531
+
532
+ assert_eq!(
533
+ targets,
534
+ vec![
535
+ "BlockLocalForwardingPanel.items",
536
+ "PatternLocalForwardingPanel.items"
537
+ ]
538
+ );
539
+ Ok(())
540
+ }
541
+
542
+ #[test]
543
+ fn forwarded_usage_counts_root_aliases() -> Result<(), Box<dyn std::error::Error>> {
544
+ let source = r"
545
+ class ForwardingPanel extends StatefulWidget {
546
+ const ForwardingPanel({super.key, required this.items, required this.unused});
547
+ final List<String> items;
548
+ final String unused;
549
+ State<ForwardingPanel> createState() => _ForwardingPanelState();
550
+ }
551
+
552
+ class _ForwardingPanelState extends State<ForwardingPanel> {
553
+ Widget build(BuildContext context) {
554
+ final owner = widget;
555
+ final data = ForwardedViewData.fromOwner(source: owner);
556
+ return Text(data.label);
557
+ }
558
+ }
559
+
560
+ class ForwardedViewData {
561
+ ForwardedViewData.fromOwner({required ForwardingPanel source})
562
+ : label = source.items.join(',');
563
+ final String label;
564
+ }
565
+ ";
566
+ let targets = unused_param_targets(parse_findings(source)?.unused_params);
567
+
568
+ assert_eq!(targets, vec!["ForwardingPanel.unused"]);
569
+ Ok(())
570
+ }
571
+
572
+ #[test]
573
+ fn forwarded_usage_ignores_root_shadows_at_invocation() -> Result<(), Box<dyn std::error::Error>> {
574
+ let source = r"
575
+ class LocalShadowForwardingPanel extends StatefulWidget {
576
+ const LocalShadowForwardingPanel({super.key, required this.items});
577
+ final List<String> items;
578
+ State<LocalShadowForwardingPanel> createState() => _LocalShadowForwardingPanelState();
579
+ }
580
+
581
+ class _LocalShadowForwardingPanelState extends State<LocalShadowForwardingPanel> {
582
+ Widget build(BuildContext context) {
583
+ final widget = const LocalShadowForwardingPanel(items: ['local']);
584
+ final data = ForwardedViewData.fromLocal(source: widget);
585
+ return Text(data.label);
586
+ }
587
+ }
588
+
589
+ class CallbackShadowForwardingPanel extends StatefulWidget {
590
+ const CallbackShadowForwardingPanel({super.key, required this.items});
591
+ final List<String> items;
592
+ State<CallbackShadowForwardingPanel> createState() => _CallbackShadowForwardingPanelState();
593
+ }
594
+
595
+ class _CallbackShadowForwardingPanelState extends State<CallbackShadowForwardingPanel> {
596
+ Widget build(BuildContext context) {
597
+ final data = [const CallbackShadowForwardingPanel(items: ['local'])]
598
+ .map((widget) => ForwardedViewData.fromCallback(source: widget))
599
+ .first;
600
+ return Text(data.label);
601
+ }
602
+ }
603
+
604
+ class CallbackAliasShadowForwardingPanel extends StatefulWidget {
605
+ const CallbackAliasShadowForwardingPanel({super.key, required this.items});
606
+ final List<String> items;
607
+ State<CallbackAliasShadowForwardingPanel> createState() => _CallbackAliasShadowForwardingPanelState();
608
+ }
609
+
610
+ class _CallbackAliasShadowForwardingPanelState extends State<CallbackAliasShadowForwardingPanel> {
611
+ Widget build(BuildContext context) {
612
+ final data = [const CallbackAliasShadowForwardingPanel(items: ['local'])]
613
+ .map((widget) {
614
+ final alias = widget;
615
+ return ForwardedViewData.fromCallbackAlias(source: alias);
616
+ })
617
+ .first;
618
+ return Text(data.label);
619
+ }
620
+ }
621
+
622
+ class ForwardedViewData {
623
+ ForwardedViewData.fromLocal({required LocalShadowForwardingPanel source})
624
+ : label = source.items.join(',');
625
+ ForwardedViewData.fromCallback({required CallbackShadowForwardingPanel source})
626
+ : label = source.items.join(',');
627
+ ForwardedViewData.fromCallbackAlias({required CallbackAliasShadowForwardingPanel source})
628
+ : label = source.items.join(',');
629
+ final String label;
630
+ }
631
+ ";
632
+ let targets = unused_param_targets(parse_findings(source)?.unused_params);
633
+
634
+ assert_eq!(
635
+ targets,
636
+ vec![
637
+ "LocalShadowForwardingPanel.items",
638
+ "CallbackShadowForwardingPanel.items",
639
+ "CallbackAliasShadowForwardingPanel.items"
640
+ ]
641
+ );
642
+ Ok(())
643
+ }
644
+
645
+ #[test]
646
+ fn forwarded_usage_ignores_header_root_shadows() -> Result<(), Box<dyn std::error::Error>> {
647
+ let source = r"
648
+ class ForHeaderForwardingPanel extends StatefulWidget {
649
+ const ForHeaderForwardingPanel({super.key, required this.items});
650
+ final List<String> items;
651
+ State<ForHeaderForwardingPanel> createState() => _ForHeaderForwardingPanelState();
652
+ }
653
+
654
+ class _ForHeaderForwardingPanelState extends State<ForHeaderForwardingPanel> {
655
+ Widget build(BuildContext context) {
656
+ for (final widget in [const ForHeaderForwardingPanel(items: ['local'])]) {
657
+ final data = ForwardedViewData.fromForHeader(source: widget);
658
+ return Text(data.label);
659
+ }
660
+ return const SizedBox();
661
+ }
662
+ }
663
+
664
+ class CatchHeaderForwardingPanel extends StatefulWidget {
665
+ const CatchHeaderForwardingPanel({super.key, required this.items});
666
+ final List<String> items;
667
+ State<CatchHeaderForwardingPanel> createState() => _CatchHeaderForwardingPanelState();
668
+ }
669
+
670
+ class _CatchHeaderForwardingPanelState extends State<CatchHeaderForwardingPanel> {
671
+ Widget build(BuildContext context) {
672
+ try {
673
+ throw Object();
674
+ } catch (widget) {
675
+ final alias = widget;
676
+ final data = ForwardedViewData.fromCatchHeader(source: alias);
677
+ return Text(data.label);
678
+ }
679
+ return const SizedBox();
680
+ }
681
+ }
682
+
683
+ class ForwardedViewData {
684
+ ForwardedViewData.fromForHeader({required ForHeaderForwardingPanel source})
685
+ : label = source.items.join(',');
686
+ ForwardedViewData.fromCatchHeader({required CatchHeaderForwardingPanel source})
687
+ : label = source.items.join(',');
688
+ final String label;
689
+ }
690
+ ";
691
+ let targets = unused_param_targets(parse_findings(source)?.unused_params);
692
+
693
+ assert_eq!(
694
+ targets,
695
+ vec![
696
+ "ForHeaderForwardingPanel.items",
697
+ "CatchHeaderForwardingPanel.items"
698
+ ]
699
+ );
700
+ Ok(())
701
+ }
702
+
703
+ #[test]
704
+ fn forwarded_usage_ignores_local_function_root_shadows() -> Result<(), Box<dyn std::error::Error>> {
705
+ let source = r"
706
+ class LocalFunctionForwardingPanel extends StatefulWidget {
707
+ const LocalFunctionForwardingPanel({super.key, required this.items});
708
+ final List<String> items;
709
+ State<LocalFunctionForwardingPanel> createState() => _LocalFunctionForwardingPanelState();
710
+ }
711
+
712
+ class _LocalFunctionForwardingPanelState extends State<LocalFunctionForwardingPanel> {
713
+ Widget build(BuildContext context) {
714
+ void widget() {}
715
+ final data = ForwardedViewData.fromLocalFunction(source: widget);
716
+ return Text(data.label);
717
+ }
718
+ }
719
+
720
+ class ForwardedViewData {
721
+ ForwardedViewData.fromLocalFunction({required LocalFunctionForwardingPanel source})
722
+ : label = source.items.join(',');
723
+ final String label;
724
+ }
725
+ ";
726
+ let targets = unused_param_targets(parse_findings(source)?.unused_params);
727
+
728
+ assert_eq!(targets, vec!["LocalFunctionForwardingPanel.items"]);
729
+ Ok(())
730
+ }
731
+
732
+ #[test]
733
+ fn forwarded_usage_ignores_shadowed_forwarder_owners() -> Result<(), Box<dyn std::error::Error>> {
734
+ let source = r"
735
+ class LocalVariableForwarderOwnerShadowPanel extends StatelessWidget {
736
+ const LocalVariableForwarderOwnerShadowPanel({super.key, required this.title});
737
+ final String title;
738
+ Widget build(BuildContext context) {
739
+ {
740
+ final ForwardedViewData = ShadowForwarder();
741
+ ForwardedViewData.fromOwner(source: this);
742
+ }
743
+ {
744
+ ShadowForwarder ForwardedViewData() => ShadowForwarder();
745
+ ForwardedViewData.fromOwner(source: this);
746
+ }
747
+ return const SizedBox();
748
+ }
749
+ }
750
+
751
+ class ParameterForwarderOwnerShadowPanel extends StatelessWidget {
752
+ const ParameterForwarderOwnerShadowPanel({super.key, required this.title});
753
+ final String title;
754
+ Widget render(ShadowForwarder ParameterForwardedViewData) {
755
+ final data = ParameterForwardedViewData.fromOwner(source: this);
756
+ return Text(data.title);
757
+ }
758
+ Widget build(BuildContext context) => render(ShadowForwarder());
759
+ }
760
+
761
+ class PatternForwarderOwnerShadowPanel extends StatelessWidget {
762
+ const PatternForwarderOwnerShadowPanel({super.key, required this.title});
763
+ final String title;
764
+ Widget build(BuildContext context) {
765
+ final record = (PatternForwardedViewData: ShadowForwarder());
766
+ final (:PatternForwardedViewData) = record;
767
+ final data = PatternForwardedViewData.fromOwner(source: this);
768
+ return Text(data.title);
769
+ }
770
+ }
771
+
772
+ class MemberForwarderOwnerShadowPanel extends StatelessWidget {
773
+ const MemberForwarderOwnerShadowPanel({super.key, required this.title});
774
+ final String title;
775
+ ShadowForwarder get MemberForwardedViewData => ShadowForwarder();
776
+ Widget build(BuildContext context) {
777
+ final data = MemberForwardedViewData.fromOwner(source: this);
778
+ return Text(data.title);
779
+ }
780
+ }
781
+
782
+ class RealForwarderPanel extends StatelessWidget {
783
+ const RealForwarderPanel({super.key, required this.title, required this.unused});
784
+ final String title;
785
+ final String unused;
786
+ Widget build(BuildContext context) {
787
+ final data = RealForwardedViewData.fromOwner(source: this);
788
+ return Text(data.title);
789
+ }
790
+ }
791
+
792
+ class ForwardedViewData {
793
+ ForwardedViewData.fromOwner({required LocalVariableForwarderOwnerShadowPanel source})
794
+ : title = source.title;
795
+ final String title;
796
+ }
797
+
798
+ class ParameterForwardedViewData {
799
+ ParameterForwardedViewData.fromOwner({required ParameterForwarderOwnerShadowPanel source})
800
+ : title = source.title;
801
+ final String title;
802
+ }
803
+
804
+ class PatternForwardedViewData {
805
+ PatternForwardedViewData.fromOwner({required PatternForwarderOwnerShadowPanel source})
806
+ : title = source.title;
807
+ final String title;
808
+ }
809
+
810
+ class MemberForwardedViewData {
811
+ MemberForwardedViewData.fromOwner({required MemberForwarderOwnerShadowPanel source})
812
+ : title = source.title;
813
+ final String title;
814
+ }
815
+
816
+ class RealForwardedViewData {
817
+ RealForwardedViewData.fromOwner({required RealForwarderPanel source})
818
+ : title = source.title;
819
+ final String title;
820
+ }
821
+
822
+ class ShadowForwarder {
823
+ ShadowForwardedData fromOwner({required Object source}) => ShadowForwardedData();
824
+ }
825
+
826
+ class ShadowForwardedData {
827
+ String get title => 'shadow';
828
+ }
829
+ ";
830
+ let targets = unused_param_targets(parse_findings(source)?.unused_params);
831
+
832
+ assert_eq!(
833
+ targets,
834
+ vec![
835
+ "LocalVariableForwarderOwnerShadowPanel.title",
836
+ "ParameterForwarderOwnerShadowPanel.title",
837
+ "PatternForwarderOwnerShadowPanel.title",
838
+ "MemberForwarderOwnerShadowPanel.title",
839
+ "RealForwarderPanel.unused"
840
+ ]
841
+ );
842
+ Ok(())
843
+ }
844
+
845
+ #[test]
846
+ fn object_pattern_usage_ignores_shadowed_root_aliases() -> Result<(), Box<dyn std::error::Error>> {
847
+ let source = r"
848
+ class AliasPatternPanel extends StatefulWidget {
849
+ const AliasPatternPanel({super.key, required this.used, required this.unused});
850
+ final String used;
851
+ final String unused;
852
+ State<AliasPatternPanel> createState() => _AliasPatternPanelState();
853
+ }
854
+
855
+ class _AliasPatternPanelState extends State<AliasPatternPanel> {
856
+ Widget build(BuildContext context) {
857
+ return Text([const AliasPatternPanel(used: 'local', unused: 'local')]
858
+ .map((widget) {
859
+ final alias = widget;
860
+ final AliasPatternPanel(:used) = alias;
861
+ return used;
862
+ })
863
+ .first);
864
+ }
865
+ }
866
+ ";
867
+ let targets = unused_param_targets(parse_findings(source)?.unused_params);
868
+
869
+ assert_eq!(
870
+ targets,
871
+ vec!["AliasPatternPanel.unused", "AliasPatternPanel.used"]
872
+ );
873
+ Ok(())
874
+ }
875
+
876
+ #[test]
877
+ fn object_pattern_usage_ignores_header_root_shadows() -> Result<(), Box<dyn std::error::Error>> {
878
+ let source = r"
879
+ class HeaderPatternPanel extends StatefulWidget {
880
+ const HeaderPatternPanel({super.key, required this.used, required this.unused});
881
+ final String used;
882
+ final String unused;
883
+ State<HeaderPatternPanel> createState() => _HeaderPatternPanelState();
884
+ }
885
+
886
+ class _HeaderPatternPanelState extends State<HeaderPatternPanel> {
887
+ Widget build(BuildContext context) {
888
+ for (final widget in [const HeaderPatternPanel(used: 'local', unused: 'local')]) {
889
+ final HeaderPatternPanel(:used) = widget;
890
+ return Text(used);
891
+ }
892
+ return const SizedBox();
893
+ }
894
+ }
895
+ ";
896
+ let targets = unused_param_targets(parse_findings(source)?.unused_params);
897
+
898
+ assert_eq!(
899
+ targets,
900
+ vec!["HeaderPatternPanel.unused", "HeaderPatternPanel.used"]
901
+ );
902
+ Ok(())
903
+ }
904
+
905
+ #[test]
906
+ fn object_pattern_usage_ignores_local_function_root_shadows()
907
+ -> Result<(), Box<dyn std::error::Error>> {
908
+ let source = r"
909
+ class LocalFunctionPatternPanel extends StatefulWidget {
910
+ const LocalFunctionPatternPanel({super.key, required this.used, required this.unused});
911
+ final String used;
912
+ final String unused;
913
+ State<LocalFunctionPatternPanel> createState() => _LocalFunctionPatternPanelState();
914
+ }
915
+
916
+ class _LocalFunctionPatternPanelState extends State<LocalFunctionPatternPanel> {
917
+ Widget build(BuildContext context) {
918
+ void widget() {}
919
+ final LocalFunctionPatternPanel(:used) = widget;
920
+ return Text(used);
921
+ }
922
+ }
923
+ ";
924
+ let targets = unused_param_targets(parse_findings(source)?.unused_params);
925
+
926
+ assert_eq!(
927
+ targets,
928
+ vec![
929
+ "LocalFunctionPatternPanel.unused",
930
+ "LocalFunctionPatternPanel.used"
931
+ ]
932
+ );
933
+ Ok(())
934
+ }
935
+
936
+ #[test]
937
+ fn object_pattern_usage_counts_root_aliases() -> Result<(), Box<dyn std::error::Error>> {
938
+ let source = r"
939
+ class AliasPatternPanel extends StatefulWidget {
940
+ const AliasPatternPanel({super.key, required this.used, required this.unused});
941
+ final String used;
942
+ final String unused;
943
+ State<AliasPatternPanel> createState() => _AliasPatternPanelState();
944
+ }
945
+
946
+ class _AliasPatternPanelState extends State<AliasPatternPanel> {
947
+ Widget build(BuildContext context) {
948
+ final owner = widget;
949
+ final AliasPatternPanel(:used) = owner;
950
+ return Text(used);
951
+ }
952
+ }
953
+ ";
954
+ let targets = unused_param_targets(parse_findings(source)?.unused_params);
955
+
956
+ assert_eq!(targets, vec!["AliasPatternPanel.unused"]);
957
+ Ok(())
958
+ }
959
+
960
+ #[test]
961
+ fn factory_forwarders_count_fields_read_from_widget_parameter()
962
+ -> Result<(), Box<dyn std::error::Error>> {
963
+ let source = r"
964
+ class FactoryForwardingPanel extends StatelessWidget {
965
+ const FactoryForwardingPanel({super.key, required this.title, required this.unused});
966
+ final String title;
967
+ final String unused;
968
+ Widget build(BuildContext context) {
969
+ final data = ForwardedTitleData.fromOwner(source: this);
970
+ return Text(data.title);
971
+ }
972
+ }
973
+
974
+ class ForwardedTitleData {
975
+ factory ForwardedTitleData.fromOwner({required FactoryForwardingPanel source}) {
976
+ return ForwardedTitleData._(source.title);
977
+ }
978
+ ForwardedTitleData._(this.title);
979
+ final String title;
980
+ }
981
+ ";
982
+ let targets = unused_param_targets(parse_findings(source)?.unused_params);
983
+
984
+ assert_eq!(targets, vec!["FactoryForwardingPanel.unused"]);
985
+ Ok(())
986
+ }
987
+
988
+ #[test]
989
+ fn forwarders_count_object_pattern_fields_read_from_widget_parameter()
990
+ -> Result<(), Box<dyn std::error::Error>> {
991
+ let source = r"
992
+ class PatternForwardingPanel extends StatelessWidget {
993
+ const PatternForwardingPanel({super.key, required this.title, required this.unused});
994
+ final String title;
995
+ final String unused;
996
+ Widget build(BuildContext context) {
997
+ final data = ForwardedTitleData.fromOwner(source: this);
998
+ return Text(data.title);
999
+ }
1000
+ }
1001
+
1002
+ class ForwardedTitleData {
1003
+ ForwardedTitleData.fromOwner({required PatternForwardingPanel source}) {
1004
+ final PatternForwardingPanel(:title) = source;
1005
+ this.title = title;
1006
+ }
1007
+ late final String title;
1008
+ }
1009
+ ";
1010
+ let targets = unused_param_targets(parse_findings(source)?.unused_params);
1011
+
1012
+ assert_eq!(targets, vec!["PatternForwardingPanel.unused"]);
1013
+ Ok(())
1014
+ }
1015
+
1016
+ #[test]
1017
+ fn forwarders_match_generic_widget_parameter_types() -> Result<(), Box<dyn std::error::Error>> {
1018
+ let source = r"
1019
+ class GenericForwarderParamPanel<T> extends StatelessWidget {
1020
+ const GenericForwarderParamPanel({super.key, required this.title, required this.unused});
1021
+ final String title;
1022
+ final String unused;
1023
+ Widget build(BuildContext context) {
1024
+ final data = GenericForwardedTitleData<T>.fromOwner(source: this);
1025
+ return Text(data.title);
1026
+ }
1027
+ }
1028
+
1029
+ class GenericForwardedTitleData<T> {
1030
+ GenericForwardedTitleData.fromOwner({required GenericForwarderParamPanel<T> source})
1031
+ : title = source.title;
1032
+ final String title;
1033
+ }
1034
+ ";
1035
+ let targets = unused_param_targets(parse_findings(source)?.unused_params);
1036
+
1037
+ assert_eq!(targets, vec!["GenericForwarderParamPanel.unused"]);
1038
+ Ok(())
1039
+ }
1040
+
1041
+ #[test]
1042
+ fn forwarded_usage_matches_generic_const_forwarder_invocations()
1043
+ -> Result<(), Box<dyn std::error::Error>> {
1044
+ let source = r"
1045
+ class GenericForwardingPanel extends StatelessWidget {
1046
+ const GenericForwardingPanel({super.key, required this.title, required this.unused});
1047
+ final String title;
1048
+ final String unused;
1049
+ Widget build(BuildContext context) {
1050
+ final data = const ForwardedTitleData<String>.fromOwner(source: this);
1051
+ return Text(data.title);
1052
+ }
1053
+ }
1054
+
1055
+ class ForwardedTitleData<T> {
1056
+ const ForwardedTitleData.fromOwner({required GenericForwardingPanel source})
1057
+ : title = source.title;
1058
+ final String title;
1059
+ }
1060
+ ";
1061
+ let targets = unused_param_targets(parse_findings(source)?.unused_params);
1062
+
1063
+ assert_eq!(targets, vec!["GenericForwardingPanel.unused"]);
1064
+ Ok(())
1065
+ }
1066
+
1067
+ #[test]
1068
+ fn forwarders_ignore_nested_callback_formals_for_positional_indexes()
1069
+ -> Result<(), Box<dyn std::error::Error>> {
1070
+ let source = r"
1071
+ class ForwarderArityPanel extends StatelessWidget {
1072
+ const ForwarderArityPanel({super.key, required this.title, required this.unused});
1073
+ final String title;
1074
+ final String unused;
1075
+ Widget build(BuildContext context) {
1076
+ String format(ForwarderArityPanel panel) => panel.title;
1077
+ final data = ForwardedTitleData.fromOwner(format, this);
1078
+ return Text(data.title);
1079
+ }
1080
+ }
1081
+
1082
+ class ForwardedTitleData {
1083
+ ForwardedTitleData.fromOwner(
1084
+ String Function(ForwarderArityPanel panel) format,
1085
+ ForwarderArityPanel source,
1086
+ ) : title = source.title;
1087
+ final String title;
1088
+ }
1089
+ ";
1090
+ let targets = unused_param_targets(parse_findings(source)?.unused_params);
1091
+
1092
+ assert_eq!(targets, vec!["ForwarderArityPanel.unused"]);
1093
+ Ok(())
1094
+ }
1095
+
1096
+ #[test]
1097
+ fn object_pattern_usage_counts_paired_nested_record_roots() -> Result<(), Box<dyn std::error::Error>>
1098
+ {
1099
+ let source = r"
1100
+ class NestedRecordRootPanel extends StatelessWidget {
1101
+ const NestedRecordRootPanel({super.key, required this.used, required this.unused});
1102
+ final String used;
1103
+ final String unused;
1104
+ Widget build(BuildContext context) {
1105
+ final (NestedRecordRootPanel(:used), _) = (this, Object());
1106
+ return Text(used);
1107
+ }
1108
+ }
1109
+
1110
+ class NestedRecordStringPanel extends StatelessWidget {
1111
+ const NestedRecordStringPanel({super.key, required this.used, required this.unused});
1112
+ final String used;
1113
+ final String unused;
1114
+ Widget build(BuildContext context) {
1115
+ final (_, NestedRecordStringPanel(:used)) = ('a,b', this);
1116
+ return Text(used);
1117
+ }
1118
+ }
1119
+
1120
+ class NestedRecordComparisonPanel extends StatelessWidget {
1121
+ const NestedRecordComparisonPanel({super.key, required this.used, required this.unused});
1122
+ final String used;
1123
+ final String unused;
1124
+ Widget build(BuildContext context) {
1125
+ final (_, NestedRecordComparisonPanel(:used)) = (count < limit, this);
1126
+ return Text(used);
1127
+ }
1128
+ }
1129
+
1130
+ class NestedRecordOtherPanel extends StatelessWidget {
1131
+ const NestedRecordOtherPanel({super.key, required this.used, required this.unused});
1132
+ final String used;
1133
+ final String unused;
1134
+ Widget build(BuildContext context) {
1135
+ final (NestedRecordOtherPanel(:used), _) =
1136
+ (const NestedRecordOtherPanel(used: 'other', unused: 'other'), this);
1137
+ return Text(used);
1138
+ }
1139
+ }
1140
+ ";
1141
+ let mut targets = unused_param_targets(parse_findings(source)?.unused_params);
1142
+ targets.sort();
1143
+
1144
+ assert_eq!(
1145
+ targets,
1146
+ vec![
1147
+ "NestedRecordComparisonPanel.unused",
1148
+ "NestedRecordOtherPanel.unused",
1149
+ "NestedRecordOtherPanel.used",
1150
+ "NestedRecordRootPanel.unused",
1151
+ "NestedRecordStringPanel.unused"
1152
+ ]
1153
+ );
1154
+ Ok(())
1155
+ }
1156
+
1157
+ #[test]
1158
+ fn object_pattern_usage_counts_typed_list_literal_roots() -> Result<(), Box<dyn std::error::Error>>
1159
+ {
1160
+ let source = r"
1161
+ class NestedTypedListPanel extends StatelessWidget {
1162
+ const NestedTypedListPanel({super.key, required this.used, required this.unused});
1163
+ final String used;
1164
+ final String unused;
1165
+ Widget build(BuildContext context) {
1166
+ final [_, NestedTypedListPanel(:used)] = <Object>[Object(), this];
1167
+ return Text(used);
1168
+ }
1169
+ }
1170
+
1171
+ class NestedConstTypedListPanel extends StatelessWidget {
1172
+ const NestedConstTypedListPanel({super.key, required this.used, required this.unused});
1173
+ final String used;
1174
+ final String unused;
1175
+ Widget build(BuildContext context) {
1176
+ final [_, NestedConstTypedListPanel(:used)] =
1177
+ const <Object>[Object(), NestedConstTypedListPanel(used: 'other', unused: 'other')];
1178
+ return Text(used);
1179
+ }
1180
+ }
1181
+ ";
1182
+ let mut targets = unused_param_targets(parse_findings(source)?.unused_params);
1183
+ targets.sort();
1184
+
1185
+ assert_eq!(
1186
+ targets,
1187
+ vec![
1188
+ "NestedConstTypedListPanel.unused",
1189
+ "NestedConstTypedListPanel.used",
1190
+ "NestedTypedListPanel.unused",
1191
+ ]
1192
+ );
1193
+ Ok(())
1194
+ }
1195
+
1196
+ #[test]
1197
+ fn object_pattern_usage_counts_paired_nested_case_roots() -> Result<(), Box<dyn std::error::Error>>
1198
+ {
1199
+ let source = r"
1200
+ class NestedIfCaseRootPanel extends StatelessWidget {
1201
+ const NestedIfCaseRootPanel({super.key, required this.used, required this.unused});
1202
+ final String used;
1203
+ final String unused;
1204
+ Widget build(BuildContext context) {
1205
+ if ((this, Object()) case (NestedIfCaseRootPanel(:used), _)) {
1206
+ return Text(used);
1207
+ }
1208
+ return const SizedBox();
1209
+ }
1210
+ }
1211
+
1212
+ class NestedSwitchCaseRootPanel extends StatelessWidget {
1213
+ const NestedSwitchCaseRootPanel({super.key, required this.used, required this.unused});
1214
+ final String used;
1215
+ final String unused;
1216
+ Widget build(BuildContext context) {
1217
+ return switch ((Object(), this)) {
1218
+ (_, NestedSwitchCaseRootPanel(:used)) => Text(used),
1219
+ };
1220
+ }
1221
+ }
1222
+
1223
+ class NestedCaseOtherPanel extends StatelessWidget {
1224
+ const NestedCaseOtherPanel({super.key, required this.used, required this.unused});
1225
+ final String used;
1226
+ final String unused;
1227
+ Widget build(BuildContext context) {
1228
+ if ((Object(), const NestedCaseOtherPanel(used: 'other', unused: 'other'))
1229
+ case (_, NestedCaseOtherPanel(:used))) {
1230
+ return Text(used);
1231
+ }
1232
+ return const SizedBox();
1233
+ }
1234
+ }
1235
+ ";
1236
+ let mut targets = unused_param_targets(parse_findings(source)?.unused_params);
1237
+ targets.sort();
1238
+
1239
+ assert_eq!(
1240
+ targets,
1241
+ vec![
1242
+ "NestedCaseOtherPanel.unused",
1243
+ "NestedCaseOtherPanel.used",
1244
+ "NestedIfCaseRootPanel.unused",
1245
+ "NestedSwitchCaseRootPanel.unused"
1246
+ ]
1247
+ );
1248
+ Ok(())
1249
+ }
1250
+
1251
+ #[test]
1252
+ fn bare_object_pattern_helper_calls_ignore_mixin_member_shadows()
1253
+ -> Result<(), Box<dyn std::error::Error>> {
1254
+ let source = r"
1255
+ class MixinShadowHelperWidget extends StatelessWidget with HelperMixin {
1256
+ const MixinShadowHelperWidget({super.key, required this.used, required this.unused});
1257
+ final String used;
1258
+ final String unused;
1259
+ Widget build(BuildContext context) => Text(mixinShadowHelper(this));
1260
+ }
1261
+
1262
+ mixin HelperMixin {
1263
+ String mixinShadowHelper(MixinShadowHelperWidget widget) => 'member';
1264
+ }
1265
+
1266
+ String mixinShadowHelper(MixinShadowHelperWidget widget) {
1267
+ final MixinShadowHelperWidget(:used) = widget;
1268
+ return used;
1269
+ }
1270
+ ";
1271
+ let mut targets = unused_param_targets(parse_findings(source)?.unused_params);
1272
+ targets.sort();
1273
+
1274
+ assert_eq!(
1275
+ targets,
1276
+ vec![
1277
+ "MixinShadowHelperWidget.unused",
1278
+ "MixinShadowHelperWidget.used"
1279
+ ]
1280
+ );
1281
+ Ok(())
1282
+ }
1283
+
1284
+ #[test]
1285
+ fn bare_object_pattern_helper_calls_ignore_unresolved_interface_shadows()
1286
+ -> Result<(), Box<dyn std::error::Error>> {
1287
+ let source = r"
1288
+ class ImportedInterfaceShadowWidget extends StatelessWidget implements ImportedHelperOwner {
1289
+ const ImportedInterfaceShadowWidget({super.key, required this.used, required this.unused});
1290
+ final String used;
1291
+ final String unused;
1292
+ Widget build(BuildContext context) => Text(importedShadowHelper(this));
1293
+ }
1294
+
1295
+ String importedShadowHelper(ImportedInterfaceShadowWidget widget) {
1296
+ final ImportedInterfaceShadowWidget(:used) = widget;
1297
+ return used;
1298
+ }
1299
+ ";
1300
+ let mut targets = unused_param_targets(parse_findings(source)?.unused_params);
1301
+ targets.sort();
1302
+
1303
+ assert_eq!(
1304
+ targets,
1305
+ vec![
1306
+ "ImportedInterfaceShadowWidget.unused",
1307
+ "ImportedInterfaceShadowWidget.used"
1308
+ ]
1309
+ );
1310
+ Ok(())
1311
+ }
1312
+
1313
+ #[test]
1314
+ fn bare_object_pattern_helper_calls_ignore_prefixed_inherited_shadows()
1315
+ -> Result<(), Box<dyn std::error::Error>> {
1316
+ let source = r"
1317
+ import 'base_screen.dart' as pkg;
1318
+
1319
+ class BaseScreen extends StatelessWidget {}
1320
+
1321
+ class PrefixedInheritedShadowWidget extends StatelessWidget with pkg.BaseScreen {
1322
+ const PrefixedInheritedShadowWidget({super.key, required this.used, required this.unused});
1323
+ final String used;
1324
+ final String unused;
1325
+ Widget build(BuildContext context) => Text(prefixedShadowHelper(this));
1326
+ }
1327
+
1328
+ String prefixedShadowHelper(PrefixedInheritedShadowWidget widget) {
1329
+ final PrefixedInheritedShadowWidget(:used) = widget;
1330
+ return used;
1331
+ }
1332
+ ";
1333
+ let mut targets = unused_param_targets(parse_findings(source)?.unused_params);
1334
+ targets.sort();
1335
+
1336
+ assert_eq!(
1337
+ targets,
1338
+ vec![
1339
+ "PrefixedInheritedShadowWidget.unused",
1340
+ "PrefixedInheritedShadowWidget.used"
1341
+ ]
1342
+ );
1343
+ Ok(())
1344
+ }
1345
+
1346
+ #[test]
1347
+ fn object_pattern_helpers_accept_prefixed_flutter_framework_superclasses()
1348
+ -> Result<(), Box<dyn std::error::Error>> {
1349
+ let source = r"
1350
+ import 'package:flutter/widgets.dart' as f;
1351
+
1352
+ class PrefixedFrameworkHelperWidget extends f.StatelessWidget {
1353
+ const PrefixedFrameworkHelperWidget({super.key, required this.used, required this.unused});
1354
+ final String used;
1355
+ final String unused;
1356
+ f.Widget build(f.BuildContext context) => f.Text(prefixedFrameworkHelper(this));
1357
+ }
1358
+
1359
+ String prefixedFrameworkHelper(PrefixedFrameworkHelperWidget widget) {
1360
+ final PrefixedFrameworkHelperWidget(:used) = widget;
1361
+ return used;
1362
+ }
1363
+ ";
1364
+ let targets = unused_param_targets(parse_findings(source)?.unused_params);
1365
+
1366
+ assert_eq!(targets, vec!["PrefixedFrameworkHelperWidget.unused"]);
1367
+ Ok(())
1368
+ }
1369
+
1370
+ #[test]
1371
+ fn object_pattern_helpers_ignore_unresolved_prefixed_framework_names()
1372
+ -> Result<(), Box<dyn std::error::Error>> {
1373
+ let source = r"
1374
+ import 'package:fake/widgets.dart' as pkg;
1375
+
1376
+ class PrefixedFakeFrameworkWidget extends pkg.StatelessWidget {
1377
+ const PrefixedFakeFrameworkWidget({super.key, required this.used, required this.unused});
1378
+ final String used;
1379
+ final String unused;
1380
+ Widget build(BuildContext context) => Text(prefixedFakeFrameworkHelper(this));
1381
+ }
1382
+
1383
+ String prefixedFakeFrameworkHelper(PrefixedFakeFrameworkWidget widget) {
1384
+ final PrefixedFakeFrameworkWidget(:used) = widget;
1385
+ return used;
1386
+ }
1387
+ ";
1388
+ let mut targets = unused_param_targets(parse_findings(source)?.unused_params);
1389
+ targets.sort();
1390
+
1391
+ assert_eq!(
1392
+ targets,
1393
+ vec![
1394
+ "PrefixedFakeFrameworkWidget.unused",
1395
+ "PrefixedFakeFrameworkWidget.used"
1396
+ ]
1397
+ );
1398
+ Ok(())
1399
+ }
1400
+
1401
+ #[test]
1402
+ fn object_pattern_method_helpers_match_inherited_mixin_calls()
1403
+ -> Result<(), Box<dyn std::error::Error>> {
1404
+ let source = r"
1405
+ mixin InheritedPatternHelperMixin {
1406
+ String readMixinHelper(InheritedMixinHelperPanel widget) {
1407
+ final InheritedMixinHelperPanel(:used) = widget;
1408
+ return used;
1409
+ }
1410
+
1411
+ String readSuperMixinHelper(SuperMixinHelperPanel widget) {
1412
+ final SuperMixinHelperPanel(:used) = widget;
1413
+ return used;
1414
+ }
1415
+ }
1416
+
1417
+ class InheritedMixinHelperPanel extends StatelessWidget with InheritedPatternHelperMixin {
1418
+ const InheritedMixinHelperPanel({super.key, required this.used, required this.unused});
1419
+ final String used;
1420
+ final String unused;
1421
+ Widget build(BuildContext context) => Text(this.readMixinHelper(this));
1422
+ }
1423
+
1424
+ class SuperMixinHelperPanel extends StatelessWidget with InheritedPatternHelperMixin {
1425
+ const SuperMixinHelperPanel({super.key, required this.used, required this.unused});
1426
+ final String used;
1427
+ final String unused;
1428
+ Widget build(BuildContext context) => Text(super.readSuperMixinHelper(this));
1429
+ }
1430
+ ";
1431
+ let mut targets = unused_param_targets(parse_findings(source)?.unused_params);
1432
+ targets.sort();
1433
+
1434
+ assert_eq!(
1435
+ targets,
1436
+ vec![
1437
+ "InheritedMixinHelperPanel.unused",
1438
+ "SuperMixinHelperPanel.unused"
1439
+ ]
1440
+ );
1441
+ Ok(())
1442
+ }
1443
+
5
1444
  #[test]
6
- fn flags_unused_stateless_widget_field_formal() -> Result<(), Box<dyn std::error::Error>> {
1445
+ fn object_pattern_method_helpers_resolve_actual_dispatch_owner()
1446
+ -> Result<(), Box<dyn std::error::Error>> {
7
1447
  let source = r"
8
- class UserCard extends StatelessWidget {
9
- const UserCard({super.key, required this.title, required this.subtitle});
1448
+ class ThisOverrideHelperPanel extends StatelessWidget with ThisOverrideHelperMixin {
1449
+ const ThisOverrideHelperPanel({super.key, required this.used, required this.unused});
1450
+ final String used;
1451
+ final String unused;
1452
+ Widget build(BuildContext context) => Text(this.readThisOverrideHelper(this));
1453
+ String readThisOverrideHelper(ThisOverrideHelperPanel widget) => 'override';
1454
+ }
1455
+
1456
+ mixin ThisOverrideHelperMixin {
1457
+ String readThisOverrideHelper(ThisOverrideHelperPanel widget) {
1458
+ final ThisOverrideHelperPanel(:used) = widget;
1459
+ return used;
1460
+ }
1461
+ }
1462
+
1463
+ class SuperOverrideLeafPanel extends StatelessWidget with SuperOverrideBaseMixin, SuperOverrideMidMixin {
1464
+ const SuperOverrideLeafPanel({super.key, required this.used, required this.unused});
1465
+ final String used;
1466
+ final String unused;
1467
+ Widget build(BuildContext context) => Text(super.readSuperOverrideHelper(this));
1468
+ }
1469
+
1470
+ mixin SuperOverrideMidMixin {
1471
+ String readSuperOverrideHelper(SuperOverrideLeafPanel widget) => 'override';
1472
+ }
1473
+
1474
+ mixin SuperOverrideBaseMixin {
1475
+ String readSuperOverrideHelper(SuperOverrideLeafPanel widget) {
1476
+ final SuperOverrideLeafPanel(:used) = widget;
1477
+ return used;
1478
+ }
1479
+ }
1480
+
1481
+ class BareInheritedHelperPanel extends StatelessWidget with BareInheritedHelperMixin {
1482
+ const BareInheritedHelperPanel({super.key, required this.used, required this.unused});
1483
+ final String used;
1484
+ final String unused;
1485
+ Widget build(BuildContext context) => Text(readBareInheritedHelper(this));
1486
+ }
1487
+
1488
+ mixin BareInheritedHelperMixin {
1489
+ String readBareInheritedHelper(BareInheritedHelperPanel widget) {
1490
+ final BareInheritedHelperPanel(:used) = widget;
1491
+ return used;
1492
+ }
1493
+ }
1494
+ ";
1495
+ let mut targets = unused_param_targets(parse_findings(source)?.unused_params);
1496
+ targets.sort();
1497
+
1498
+ assert_eq!(
1499
+ targets,
1500
+ vec![
1501
+ "BareInheritedHelperPanel.unused",
1502
+ "SuperOverrideLeafPanel.unused",
1503
+ "SuperOverrideLeafPanel.used",
1504
+ "ThisOverrideHelperPanel.unused",
1505
+ "ThisOverrideHelperPanel.used"
1506
+ ]
1507
+ );
1508
+ Ok(())
1509
+ }
1510
+
1511
+ #[test]
1512
+ fn object_pattern_helpers_match_generic_invocations_and_parameter_types()
1513
+ -> Result<(), Box<dyn std::error::Error>> {
1514
+ let source = r"
1515
+ class GenericHelperPanel<T> extends StatelessWidget {
1516
+ const GenericHelperPanel({super.key, required this.title, required this.unused});
10
1517
  final String title;
11
- final String subtitle;
12
- Widget build(BuildContext context) => Text(title);
1518
+ final String unused;
1519
+ Widget build(BuildContext context) => Text(readGenericHelper<T>(this));
1520
+ }
1521
+
1522
+ String readGenericHelper<T>(GenericHelperPanel<T> widget) {
1523
+ final GenericHelperPanel<T>(:title) = widget;
1524
+ return title;
13
1525
  }
14
1526
  ";
15
- let unused = parse_findings(source)?.unused_params;
1527
+ let targets = unused_param_targets(parse_findings(source)?.unused_params);
16
1528
 
17
- assert_eq!(unused.len(), 1);
18
- assert_eq!(unused[0].widget_class, "UserCard");
19
- assert_eq!(unused[0].param_name, "subtitle");
20
- assert_eq!(unused[0].location.line, 3);
1529
+ assert_eq!(targets, vec!["GenericHelperPanel.unused"]);
21
1530
  Ok(())
22
1531
  }
23
1532
 
24
1533
  #[test]
25
- fn flags_unused_explicit_widget_constructor_params() -> Result<(), Box<dyn std::error::Error>> {
1534
+ fn object_pattern_helpers_ignore_nested_callback_formals_for_positional_indexes()
1535
+ -> Result<(), Box<dyn std::error::Error>> {
26
1536
  let source = r"
27
- class UserCard extends StatelessWidget {
28
- const UserCard({super.key, required String unused, required String used})
29
- : unused = unused,
30
- used = used;
1537
+ class HelperArityPanel extends StatelessWidget {
1538
+ const HelperArityPanel({super.key, required this.title, required this.unused});
1539
+ final String title;
1540
+ final String unused;
1541
+ Widget build(BuildContext context) {
1542
+ String format(HelperArityPanel panel) => panel.title;
1543
+ return Text(readHelperArity(format, this));
1544
+ }
1545
+ }
1546
+
1547
+ String readHelperArity(
1548
+ String Function(HelperArityPanel panel) format,
1549
+ HelperArityPanel widget,
1550
+ ) {
1551
+ final HelperArityPanel(:title) = widget;
1552
+ return title;
1553
+ }
1554
+ ";
1555
+ let targets = unused_param_targets(parse_findings(source)?.unused_params);
1556
+
1557
+ assert_eq!(targets, vec!["HelperArityPanel.unused"]);
1558
+ Ok(())
1559
+ }
1560
+
1561
+ #[test]
1562
+ fn root_aliases_do_not_survive_reassignment() -> Result<(), Box<dyn std::error::Error>> {
1563
+ let source = r"
1564
+ class ReassignedForwardingAliasPanel extends StatelessWidget {
1565
+ const ReassignedForwardingAliasPanel({super.key, required this.used, required this.unused});
1566
+ final String used;
31
1567
  final String unused;
1568
+ Widget build(BuildContext context) {
1569
+ var owner = this;
1570
+ owner = const OtherPanel(used: 'other', unused: 'other');
1571
+ final data = ForwardedAliasData.fromOwner(source: owner);
1572
+ return Text(data.used);
1573
+ }
1574
+ }
1575
+
1576
+ class ReassignedPatternAliasPanel extends StatelessWidget {
1577
+ const ReassignedPatternAliasPanel({super.key, required this.used, required this.unused});
1578
+ final String used;
1579
+ final String unused;
1580
+ Widget build(BuildContext context) {
1581
+ var owner = this;
1582
+ owner = const OtherPanel(used: 'other', unused: 'other');
1583
+ final ReassignedPatternAliasPanel(:used) = owner;
1584
+ return Text(used);
1585
+ }
1586
+ }
1587
+
1588
+ class OtherPanel extends StatelessWidget {
1589
+ const OtherPanel({super.key, required this.used, required this.unused});
1590
+ final String used;
1591
+ final String unused;
1592
+ Widget build(BuildContext context) => Text('$used$unused');
1593
+ }
1594
+
1595
+ class ForwardedAliasData {
1596
+ ForwardedAliasData.fromOwner({required ReassignedForwardingAliasPanel source})
1597
+ : used = source.used;
32
1598
  final String used;
33
- Widget build(BuildContext context) => Text(used);
34
1599
  }
35
1600
  ";
36
- let unused = parse_findings(source)?.unused_params;
1601
+ let mut targets = unused_param_targets(parse_findings(source)?.unused_params);
1602
+ targets.sort();
37
1603
 
38
- assert_eq!(unused.len(), 1);
39
- assert_eq!(unused[0].widget_class, "UserCard");
40
- assert_eq!(unused[0].param_name, "unused");
41
- assert_eq!(unused[0].location.line, 3);
1604
+ assert_eq!(
1605
+ targets,
1606
+ vec![
1607
+ "ReassignedForwardingAliasPanel.unused",
1608
+ "ReassignedForwardingAliasPanel.used",
1609
+ "ReassignedPatternAliasPanel.unused",
1610
+ "ReassignedPatternAliasPanel.used",
1611
+ ]
1612
+ );
42
1613
  Ok(())
43
1614
  }
44
1615
 
45
1616
  #[test]
46
- fn respects_explicit_params_used_through_backing_fields_and_state()
1617
+ fn root_aliases_survive_block_local_shadow_reassignment() -> Result<(), Box<dyn std::error::Error>>
1618
+ {
1619
+ let source = r"
1620
+ class BlockShadowForwardingAliasPanel extends StatelessWidget {
1621
+ const BlockShadowForwardingAliasPanel({super.key, required this.used, required this.unused});
1622
+ final String used;
1623
+ final String unused;
1624
+ Widget build(BuildContext context) {
1625
+ final owner = this;
1626
+ if (condition) {
1627
+ var owner = const OtherPanel(used: 'other', unused: 'other');
1628
+ owner = const OtherPanel(used: 'other', unused: 'other');
1629
+ }
1630
+ final data = ForwardedBlockAliasData.fromOwner(source: owner);
1631
+ return Text(data.used);
1632
+ }
1633
+ }
1634
+
1635
+ class BlockShadowPatternAliasPanel extends StatelessWidget {
1636
+ const BlockShadowPatternAliasPanel({super.key, required this.used, required this.unused});
1637
+ final String used;
1638
+ final String unused;
1639
+ Widget build(BuildContext context) {
1640
+ final owner = this;
1641
+ if (condition) {
1642
+ var owner = const OtherPanel(used: 'other', unused: 'other');
1643
+ owner = const OtherPanel(used: 'other', unused: 'other');
1644
+ }
1645
+ final BlockShadowPatternAliasPanel(:used) = owner;
1646
+ return Text(used);
1647
+ }
1648
+ }
1649
+
1650
+ class OtherPanel extends StatelessWidget {
1651
+ const OtherPanel({super.key, required this.used, required this.unused});
1652
+ final String used;
1653
+ final String unused;
1654
+ Widget build(BuildContext context) => Text('$used$unused');
1655
+ }
1656
+
1657
+ class ForwardedBlockAliasData {
1658
+ ForwardedBlockAliasData.fromOwner({required BlockShadowForwardingAliasPanel source})
1659
+ : used = source.used;
1660
+ final String used;
1661
+ }
1662
+ ";
1663
+ let mut targets = unused_param_targets(parse_findings(source)?.unused_params);
1664
+ targets.sort();
1665
+
1666
+ assert_eq!(
1667
+ targets,
1668
+ vec![
1669
+ "BlockShadowForwardingAliasPanel.unused",
1670
+ "BlockShadowPatternAliasPanel.unused",
1671
+ ]
1672
+ );
1673
+ Ok(())
1674
+ }
1675
+
1676
+ #[test]
1677
+ fn root_aliases_survive_this_member_assignment() -> Result<(), Box<dyn std::error::Error>> {
1678
+ let source = r"
1679
+ class ThisMemberAssignmentAliasPanel extends StatelessWidget {
1680
+ const ThisMemberAssignmentAliasPanel({super.key, required this.used, required this.unused});
1681
+ final String used;
1682
+ final String unused;
1683
+ OtherPanel? owner;
1684
+ Widget build(BuildContext context) {
1685
+ final owner = this;
1686
+ this.owner = const OtherPanel(used: 'other', unused: 'other');
1687
+ final data = ForwardedThisMemberAliasData.fromOwner(source: owner);
1688
+ return Text(data.used);
1689
+ }
1690
+ }
1691
+
1692
+ class OtherPanel extends StatelessWidget {
1693
+ const OtherPanel({super.key, required this.used, required this.unused});
1694
+ final String used;
1695
+ final String unused;
1696
+ Widget build(BuildContext context) => Text('$used$unused');
1697
+ }
1698
+
1699
+ class ForwardedThisMemberAliasData {
1700
+ ForwardedThisMemberAliasData.fromOwner({required ThisMemberAssignmentAliasPanel source})
1701
+ : used = source.used;
1702
+ final String used;
1703
+ }
1704
+ ";
1705
+ let targets = unused_param_targets(parse_findings(source)?.unused_params);
1706
+
1707
+ assert_eq!(targets, vec!["ThisMemberAssignmentAliasPanel.unused"]);
1708
+ Ok(())
1709
+ }
1710
+
1711
+ #[test]
1712
+ fn bare_object_pattern_helper_calls_ignore_prior_callback_shadows()
47
1713
  -> Result<(), Box<dyn std::error::Error>> {
48
1714
  let source = r"
49
- class UserCard extends StatelessWidget {
50
- const UserCard({super.key, required String label}) : _label = label;
51
- final String _label;
52
- Widget build(BuildContext context) => Text(_label);
1715
+ class CallbackShadowHelperPanel extends StatelessWidget {
1716
+ const CallbackShadowHelperPanel({super.key, required this.used, required this.unused});
1717
+ final String used;
1718
+ final String unused;
1719
+ Widget build(BuildContext context) {
1720
+ final callbacks = ['local'].map((readCallbackHelper) => readCallbackHelper).toList();
1721
+ return Text(readCallbackHelper(this));
1722
+ }
53
1723
  }
54
- class CounterCard extends StatefulWidget {
55
- const CounterCard({super.key, required int count}) : _count = count;
56
- final int _count;
57
- State<CounterCard> createState() => _CounterCardState();
1724
+
1725
+ String readCallbackHelper(CallbackShadowHelperPanel widget) {
1726
+ final CallbackShadowHelperPanel(:used) = widget;
1727
+ return used;
58
1728
  }
59
- class _CounterCardState extends State<CounterCard> {
60
- Widget build(BuildContext context) => Text('${widget._count}');
1729
+ ";
1730
+ let targets = unused_param_targets(parse_findings(source)?.unused_params);
1731
+
1732
+ assert_eq!(targets, vec!["CallbackShadowHelperPanel.unused"]);
1733
+ Ok(())
1734
+ }
1735
+
1736
+ #[test]
1737
+ fn bare_object_pattern_helper_calls_ignore_header_shadows() -> Result<(), Box<dyn std::error::Error>>
1738
+ {
1739
+ let source = r"
1740
+ class HeaderShadowHelperPanel extends StatelessWidget {
1741
+ const HeaderShadowHelperPanel({super.key, required this.used, required this.unused});
1742
+ final String used;
1743
+ final String unused;
1744
+ Widget build(BuildContext context) {
1745
+ if (Object() case final readHeaderHelper) {
1746
+ return Text(readHeaderHelper(this));
1747
+ }
1748
+ return const SizedBox();
1749
+ }
1750
+ }
1751
+
1752
+ String readHeaderHelper(HeaderShadowHelperPanel widget) {
1753
+ final HeaderShadowHelperPanel(:used) = widget;
1754
+ return used;
61
1755
  }
62
1756
  ";
63
- let unused = parse_findings(source)?.unused_params;
1757
+ let mut targets = unused_param_targets(parse_findings(source)?.unused_params);
1758
+ targets.sort();
64
1759
 
65
- assert!(unused.is_empty(), "{unused:?}");
1760
+ assert_eq!(
1761
+ targets,
1762
+ vec![
1763
+ "HeaderShadowHelperPanel.unused",
1764
+ "HeaderShadowHelperPanel.used"
1765
+ ]
1766
+ );
66
1767
  Ok(())
67
1768
  }
68
1769
 
69
1770
  #[test]
70
- fn flags_explicit_params_when_backing_field_is_unused() -> Result<(), Box<dyn std::error::Error>> {
1771
+ fn qualified_object_pattern_helpers_resolve_unshadowed_owner()
1772
+ -> Result<(), Box<dyn std::error::Error>> {
71
1773
  let source = r"
72
- class UserCard extends StatelessWidget {
73
- const UserCard({super.key, required String subtitle}) : _subtitle = subtitle;
74
- final String _subtitle;
75
- Widget build(BuildContext context) => const SizedBox();
1774
+ class QualifiedHelperPanel extends StatelessWidget {
1775
+ const QualifiedHelperPanel({super.key, required this.used, required this.unused});
1776
+ final String used;
1777
+ final String unused;
1778
+ Widget build(BuildContext context) => Text(HelperDetails.fromDisplay(this));
1779
+ }
1780
+
1781
+ class HelperDetails {
1782
+ static String fromDisplay(QualifiedHelperPanel widget) {
1783
+ final QualifiedHelperPanel(:used) = widget;
1784
+ return used;
1785
+ }
76
1786
  }
77
1787
  ";
78
- let unused = parse_findings(source)?.unused_params;
1788
+ let targets = unused_param_targets(parse_findings(source)?.unused_params);
79
1789
 
80
- assert_eq!(unused.len(), 1);
81
- assert_eq!(unused[0].param_name, "subtitle");
1790
+ assert_eq!(targets, vec!["QualifiedHelperPanel.unused"]);
82
1791
  Ok(())
83
1792
  }
84
1793
 
85
1794
  #[test]
86
- fn respects_widget_and_state_usages() -> Result<(), Box<dyn std::error::Error>> {
1795
+ fn qualified_object_pattern_helpers_ignore_shadowed_owner() -> Result<(), Box<dyn std::error::Error>>
1796
+ {
87
1797
  let source = r"
88
- class UsedInBuild extends StatelessWidget {
89
- const UsedInBuild({super.key, required this.title});
90
- final String title;
91
- Widget build(BuildContext context) => Text('$title');
1798
+ class QualifiedShadowHelperPanel extends StatelessWidget {
1799
+ const QualifiedShadowHelperPanel({super.key, required this.used, required this.unused});
1800
+ final String used;
1801
+ final String unused;
1802
+ Widget build(BuildContext context) {
1803
+ final HelperDetails = LocalHelperDetails();
1804
+ return Text(HelperDetails.fromDisplay(this));
1805
+ }
92
1806
  }
93
- class UsedViaState extends StatefulWidget {
94
- const UsedViaState({super.key, required this.count});
95
- final int count;
96
- State<UsedViaState> createState() => _UsedViaStateState();
1807
+
1808
+ class HelperDetails {
1809
+ static String fromDisplay(QualifiedShadowHelperPanel widget) {
1810
+ final QualifiedShadowHelperPanel(:used) = widget;
1811
+ return used;
1812
+ }
97
1813
  }
98
- class _UsedViaStateState extends State<UsedViaState> {
99
- Widget build(BuildContext context) => Text('${widget.count}');
1814
+
1815
+ class LocalHelperDetails {
1816
+ String fromDisplay(QualifiedShadowHelperPanel widget) => 'local';
100
1817
  }
101
1818
  ";
102
- let unused = parse_findings(source)?.unused_params;
1819
+ let mut targets = unused_param_targets(parse_findings(source)?.unused_params);
1820
+ targets.sort();
103
1821
 
104
- assert!(unused.is_empty(), "{unused:?}");
1822
+ assert_eq!(
1823
+ targets,
1824
+ vec![
1825
+ "QualifiedShadowHelperPanel.unused",
1826
+ "QualifiedShadowHelperPanel.used"
1827
+ ]
1828
+ );
1829
+ Ok(())
1830
+ }
1831
+
1832
+ #[test]
1833
+ fn non_class_object_pattern_methods_do_not_match_bare_helper_calls()
1834
+ -> Result<(), Box<dyn std::error::Error>> {
1835
+ let source = r"
1836
+ class ExtensionMethodHelperPanel extends StatelessWidget {
1837
+ const ExtensionMethodHelperPanel({super.key, required this.used, required this.unused});
1838
+ final String used;
1839
+ final String unused;
1840
+ Widget build(BuildContext context) => Text(readExtensionHelper(this));
1841
+ }
1842
+
1843
+ extension ExtensionHelper on Object {
1844
+ String readExtensionHelper(ExtensionMethodHelperPanel widget) {
1845
+ final ExtensionMethodHelperPanel(:used) = widget;
1846
+ return used;
1847
+ }
1848
+ }
1849
+
1850
+ String readExtensionHelper(ExtensionMethodHelperPanel widget) => 'not a pattern helper';
1851
+
1852
+ class MixinMethodHelperPanel extends StatelessWidget {
1853
+ const MixinMethodHelperPanel({super.key, required this.used, required this.unused});
1854
+ final String used;
1855
+ final String unused;
1856
+ Widget build(BuildContext context) => Text(readMixinHelper(this));
1857
+ }
1858
+
1859
+ mixin DetachedHelperMixin {
1860
+ String readMixinHelper(MixinMethodHelperPanel widget) {
1861
+ final MixinMethodHelperPanel(:used) = widget;
1862
+ return used;
1863
+ }
1864
+ }
1865
+
1866
+ String readMixinHelper(MixinMethodHelperPanel widget) => 'not a pattern helper';
1867
+ ";
1868
+ let mut targets = unused_param_targets(parse_findings(source)?.unused_params);
1869
+ targets.sort();
1870
+
1871
+ assert_eq!(
1872
+ targets,
1873
+ vec![
1874
+ "ExtensionMethodHelperPanel.unused",
1875
+ "ExtensionMethodHelperPanel.used",
1876
+ "MixinMethodHelperPanel.unused",
1877
+ "MixinMethodHelperPanel.used"
1878
+ ]
1879
+ );
105
1880
  Ok(())
106
1881
  }
107
1882
 
@@ -428,3 +2203,10 @@ fn parse_findings_at(path: &str, source: &str) -> Result<FileWidgetFindings, Wid
428
2203
  parsed.source(),
429
2204
  ))
430
2205
  }
2206
+
2207
+ fn unused_param_targets(unused: Vec<UnusedWidgetParam>) -> Vec<String> {
2208
+ unused
2209
+ .into_iter()
2210
+ .map(|param| format!("{}.{}", param.widget_class, param.param_name))
2211
+ .collect()
2212
+ }