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.
@@ -0,0 +1,730 @@
1
+ use std::collections::{BTreeMap, BTreeSet};
2
+ use std::fs;
3
+ use std::path::PathBuf;
4
+
5
+ use tree_sitter::Node;
6
+
7
+ use crate::{DartFile, DependencyCycle, DependencyKind, ResolvedDependency, scan::ScannedProject};
8
+
9
+ mod aliases;
10
+ mod navigation;
11
+ mod receivers;
12
+ mod state_context;
13
+ #[cfg(test)]
14
+ mod tests;
15
+
16
+ use aliases::{route_alias_receiver_node, route_alias_receiver_text, route_aliases_at};
17
+ use navigation::{
18
+ navigation_receiver_accepts_route_location, route_extension_navigation_has_context_argument,
19
+ };
20
+ use receivers::route_extension_receiver_node;
21
+ use state_context::class_extends_state;
22
+
23
+ pub(super) fn is_typed_go_router_registry_cycle(
24
+ project: &ScannedProject,
25
+ cycle: &DependencyCycle,
26
+ ) -> bool {
27
+ let cycle_files = cycle.files.iter().cloned().collect::<BTreeSet<_>>();
28
+ let route_files = project
29
+ .files
30
+ .iter()
31
+ .filter(|file| cycle_files.contains(&file.path) && is_typed_go_router_registry(file))
32
+ .map(|file| file.path.clone())
33
+ .collect::<BTreeSet<_>>();
34
+ if route_files.is_empty() {
35
+ return false;
36
+ }
37
+
38
+ let dependencies = project.graph.dependencies();
39
+ let internal_dependencies = dependencies
40
+ .iter()
41
+ .filter(|dependency| {
42
+ cycle_files.contains(&dependency.from_path)
43
+ && cycle_files.contains(&dependency.to_path)
44
+ && dependency.from_path != dependency.to_path
45
+ })
46
+ .collect::<Vec<_>>();
47
+ let files_by_path = project
48
+ .files
49
+ .iter()
50
+ .map(|file| (file.path.clone(), file))
51
+ .collect::<BTreeMap<_, _>>();
52
+ if internal_dependencies.is_empty()
53
+ || internal_dependencies.iter().any(|dependency| {
54
+ !is_typed_go_router_registry_edge(dependency, &route_files, &files_by_path)
55
+ })
56
+ {
57
+ return false;
58
+ }
59
+
60
+ let mut route_helpers = BTreeMap::<PathBuf, BTreeSet<PathBuf>>::new();
61
+ for dependency in &internal_dependencies {
62
+ if route_files.contains(&dependency.from_path) {
63
+ route_helpers
64
+ .entry(dependency.from_path.clone())
65
+ .or_default()
66
+ .insert(dependency.to_path.clone());
67
+ }
68
+ }
69
+
70
+ let helper_files = cycle_files
71
+ .difference(&route_files)
72
+ .cloned()
73
+ .collect::<BTreeSet<_>>();
74
+ !helper_files.is_empty()
75
+ && route_files.iter().all(|route_file| {
76
+ route_helpers
77
+ .get(route_file)
78
+ .is_some_and(|helpers| !helpers.is_empty())
79
+ })
80
+ && helper_files.iter().all(|helper_file| {
81
+ route_files.iter().any(|route_file| {
82
+ route_helpers
83
+ .get(route_file)
84
+ .is_some_and(|helpers| helpers.contains(helper_file))
85
+ && internal_dependencies.iter().any(|dependency| {
86
+ dependency.from_path == *helper_file && dependency.to_path == *route_file
87
+ })
88
+ })
89
+ })
90
+ }
91
+
92
+ fn is_typed_go_router_registry_edge(
93
+ dependency: &ResolvedDependency,
94
+ route_files: &BTreeSet<PathBuf>,
95
+ files_by_path: &BTreeMap<PathBuf, &DartFile>,
96
+ ) -> bool {
97
+ if dependency.kind != DependencyKind::Import {
98
+ return false;
99
+ }
100
+ let from_is_route = route_files.contains(&dependency.from_path);
101
+ let to_is_route = route_files.contains(&dependency.to_path);
102
+ if from_is_route == to_is_route {
103
+ return false;
104
+ }
105
+ let route_path = if from_is_route {
106
+ &dependency.from_path
107
+ } else {
108
+ &dependency.to_path
109
+ };
110
+ let helper_path = if from_is_route {
111
+ &dependency.to_path
112
+ } else {
113
+ &dependency.from_path
114
+ };
115
+ let Some(route_file) = files_by_path.get(route_path) else {
116
+ return false;
117
+ };
118
+ let Some(helper_file) = files_by_path.get(helper_path) else {
119
+ return false;
120
+ };
121
+ is_typed_go_router_navigation_helper(helper_file, route_file)
122
+ }
123
+
124
+ fn is_typed_go_router_navigation_helper(helper_file: &DartFile, route_file: &DartFile) -> bool {
125
+ let route_classes = route_file
126
+ .routes
127
+ .iter()
128
+ .map(|route| route.route_class.clone())
129
+ .collect::<BTreeSet<_>>();
130
+ if route_classes.is_empty() {
131
+ return false;
132
+ }
133
+ let Ok(source) = fs::read_to_string(&helper_file.path) else {
134
+ return false;
135
+ };
136
+ let Ok(parsed) = crate::dart_parser::parse_dart_source_lossy(&helper_file.path, &source) else {
137
+ return false;
138
+ };
139
+ helper_has_typed_route_navigation_call(
140
+ parsed.tree().root_node(),
141
+ parsed.source(),
142
+ &route_classes,
143
+ )
144
+ }
145
+
146
+ fn helper_has_typed_route_navigation_call(
147
+ root: Node<'_>,
148
+ source: &str,
149
+ route_classes: &BTreeSet<String>,
150
+ ) -> bool {
151
+ let mut found = false;
152
+ visit_named(root, &mut |node| {
153
+ if found {
154
+ return;
155
+ }
156
+ if typed_route_navigation_call(root, node, source, route_classes) {
157
+ found = true;
158
+ }
159
+ });
160
+ found
161
+ }
162
+
163
+ fn typed_route_navigation_call(
164
+ root: Node<'_>,
165
+ node: Node<'_>,
166
+ source: &str,
167
+ route_classes: &BTreeSet<String>,
168
+ ) -> bool {
169
+ if !matches!(
170
+ node.kind(),
171
+ "call_expression" | "function_expression_invocation"
172
+ ) {
173
+ return false;
174
+ }
175
+ let Some(arguments) = argument_list(node) else {
176
+ return false;
177
+ };
178
+ let Some(prefix) = source.get(node.start_byte()..arguments.start_byte()) else {
179
+ return false;
180
+ };
181
+ let Some(navigation_name) = navigation_call_name(prefix) else {
182
+ return false;
183
+ };
184
+ route_extension_navigation_call(
185
+ root,
186
+ node,
187
+ prefix,
188
+ &navigation_name,
189
+ arguments,
190
+ route_classes,
191
+ source,
192
+ ) || route_location_navigation_call(
193
+ root,
194
+ node,
195
+ prefix,
196
+ &navigation_name,
197
+ arguments,
198
+ route_classes,
199
+ source,
200
+ )
201
+ }
202
+
203
+ fn argument_list(node: Node<'_>) -> Option<Node<'_>> {
204
+ node.child_by_field_name("arguments")
205
+ .or_else(|| direct_named_child(node, "arguments"))
206
+ .or_else(|| direct_named_child(node, "argument_part"))
207
+ }
208
+
209
+ fn navigation_call_name(prefix: &str) -> Option<String> {
210
+ let compact = strip_whitespace(prefix);
211
+ let name = compact.rsplit('.').next().unwrap_or(compact.as_str());
212
+ let name = strip_method_type_arguments(name);
213
+ is_typed_route_navigation_reference(name).then(|| name.to_owned())
214
+ }
215
+
216
+ fn route_extension_navigation_call(
217
+ root: Node<'_>,
218
+ site: Node<'_>,
219
+ prefix: &str,
220
+ navigation_name: &str,
221
+ arguments: Node<'_>,
222
+ route_classes: &BTreeSet<String>,
223
+ source: &str,
224
+ ) -> bool {
225
+ if !route_extension_navigation_has_context_argument(root, site, arguments, source) {
226
+ return false;
227
+ }
228
+ let compact = strip_whitespace(prefix);
229
+ let Some(receiver) = strip_navigation_suffix(&compact, ".", navigation_name) else {
230
+ return false;
231
+ };
232
+ let aliases = route_aliases_at(root, site, route_classes, source);
233
+ if route_alias_receiver_text(receiver, &aliases) {
234
+ return true;
235
+ }
236
+ if route_extension_receiver_node(site, navigation_name, source)
237
+ .is_some_and(|receiver| route_constructor_receiver(root, receiver, route_classes, source))
238
+ {
239
+ return true;
240
+ }
241
+ if route_classes.iter().any(|route_class| {
242
+ direct_constructor_call_matches_route(root, receiver, route_class, source)
243
+ }) {
244
+ return true;
245
+ }
246
+ let Some(raw_receiver) = raw_receiver_before_navigation(prefix, navigation_name) else {
247
+ return false;
248
+ };
249
+ let constructor_receiver = constructor_receiver_text(raw_receiver);
250
+ route_classes.iter().any(|route_class| {
251
+ direct_constructor_call_matches_route(root, &constructor_receiver, route_class, source)
252
+ })
253
+ }
254
+
255
+ fn route_location_navigation_call(
256
+ root: Node<'_>,
257
+ site: Node<'_>,
258
+ prefix: &str,
259
+ navigation_name: &str,
260
+ arguments: Node<'_>,
261
+ route_classes: &BTreeSet<String>,
262
+ source: &str,
263
+ ) -> bool {
264
+ navigation_receiver(prefix, navigation_name).is_some_and(|receiver| {
265
+ navigation_receiver_accepts_route_location(root, site, &receiver, source)
266
+ }) && arguments_contain_route_location(arguments, root, site, route_classes, source)
267
+ }
268
+
269
+ fn navigation_receiver(prefix: &str, navigation_name: &str) -> Option<String> {
270
+ let compact = strip_whitespace(prefix);
271
+ for separator in [".", "?."] {
272
+ if let Some(receiver) = strip_navigation_suffix(&compact, separator, navigation_name) {
273
+ return (!receiver.is_empty()).then(|| receiver.to_owned());
274
+ }
275
+ }
276
+ None
277
+ }
278
+
279
+ fn strip_navigation_suffix<'source>(
280
+ compact: &'source str,
281
+ separator: &str,
282
+ navigation_name: &str,
283
+ ) -> Option<&'source str> {
284
+ let suffix = format!("{separator}{navigation_name}");
285
+ if let Some(receiver) = compact.strip_suffix(&suffix) {
286
+ return Some(receiver);
287
+ }
288
+ let typed_suffix = format!("{suffix}<");
289
+ let start = compact.rfind(&typed_suffix)?;
290
+ let type_arguments = compact.get(start + suffix.len()..)?;
291
+ balanced_enclosed_text(type_arguments, '<', '>').then(|| &compact[..start])
292
+ }
293
+
294
+ fn raw_receiver_before_navigation<'source>(
295
+ prefix: &'source str,
296
+ navigation_name: &str,
297
+ ) -> Option<&'source str> {
298
+ let trimmed = prefix.trim_end();
299
+ let separator = trimmed.rfind('.')?;
300
+ let method = strip_whitespace(trimmed.get(separator + 1..)?.trim());
301
+ (strip_method_type_arguments(&method) == navigation_name)
302
+ .then(|| trimmed[..separator].trim_end())
303
+ }
304
+
305
+ fn constructor_receiver_text(receiver: &str) -> String {
306
+ let trimmed = receiver.trim();
307
+ let unwrapped = unwrap_parenthesized_text(trimmed).unwrap_or(trimmed);
308
+ let without_keyword = strip_constructor_keyword_prefix(unwrapped).unwrap_or(unwrapped);
309
+ strip_whitespace(without_keyword)
310
+ }
311
+
312
+ fn strip_constructor_keyword_prefix(text: &str) -> Option<&str> {
313
+ for keyword in ["const", "new"] {
314
+ let Some(rest) = text.strip_prefix(keyword) else {
315
+ continue;
316
+ };
317
+ if rest.chars().next().is_some_and(char::is_whitespace) {
318
+ return Some(rest.trim_start());
319
+ }
320
+ }
321
+ None
322
+ }
323
+
324
+ fn arguments_contain_route_location(
325
+ arguments: Node<'_>,
326
+ root: Node<'_>,
327
+ site: Node<'_>,
328
+ route_classes: &BTreeSet<String>,
329
+ source: &str,
330
+ ) -> bool {
331
+ route_location_argument(arguments).is_some_and(|argument| {
332
+ route_location_expression(argument, root, site, route_classes, source)
333
+ })
334
+ }
335
+
336
+ fn route_location_argument(arguments: Node<'_>) -> Option<Node<'_>> {
337
+ let mut cursor = arguments.walk();
338
+ arguments
339
+ .named_children(&mut cursor)
340
+ .find(|argument| argument.kind() != "named_argument")
341
+ }
342
+
343
+ fn route_location_expression(
344
+ node: Node<'_>,
345
+ root: Node<'_>,
346
+ site: Node<'_>,
347
+ route_classes: &BTreeSet<String>,
348
+ source: &str,
349
+ ) -> bool {
350
+ route_location_member(
351
+ unwrap_expression_node(node),
352
+ root,
353
+ site,
354
+ route_classes,
355
+ source,
356
+ )
357
+ }
358
+
359
+ fn unwrap_expression_node(mut node: Node<'_>) -> Node<'_> {
360
+ loop {
361
+ if !matches!(node.kind(), "parenthesized_expression" | "expression") {
362
+ return node;
363
+ }
364
+ let mut cursor = node.walk();
365
+ let mut children = node.named_children(&mut cursor);
366
+ let Some(child) = children.next() else {
367
+ return node;
368
+ };
369
+ if children.next().is_some() {
370
+ return node;
371
+ }
372
+ node = child;
373
+ }
374
+ }
375
+
376
+ fn route_location_member(
377
+ node: Node<'_>,
378
+ root: Node<'_>,
379
+ site: Node<'_>,
380
+ route_classes: &BTreeSet<String>,
381
+ source: &str,
382
+ ) -> bool {
383
+ if !matches!(
384
+ node.kind(),
385
+ "member_expression" | "null_aware_member_expression" | "assignable_expression"
386
+ ) {
387
+ return false;
388
+ }
389
+ let Some(property) = node.child_by_field_name("property") else {
390
+ return false;
391
+ };
392
+ if property.utf8_text(source.as_bytes()).ok() != Some("location") {
393
+ return false;
394
+ }
395
+ let Some(object) = node.child_by_field_name("object") else {
396
+ return false;
397
+ };
398
+ route_constructor_receiver(root, object, route_classes, source)
399
+ || route_alias_receiver_node(
400
+ object,
401
+ &route_aliases_at(root, site, route_classes, source),
402
+ source,
403
+ )
404
+ }
405
+
406
+ pub(super) fn route_constructor_receiver(
407
+ root: Node<'_>,
408
+ node: Node<'_>,
409
+ route_classes: &BTreeSet<String>,
410
+ source: &str,
411
+ ) -> bool {
412
+ if matches!(node.kind(), "parenthesized_expression" | "expression") {
413
+ let mut cursor = node.walk();
414
+ return node
415
+ .named_children(&mut cursor)
416
+ .any(|child| route_constructor_receiver(root, child, route_classes, source));
417
+ }
418
+ if matches!(
419
+ node.kind(),
420
+ "constructor_invocation" | "const_object_expression" | "new_expression"
421
+ ) && constructor_receiver_matches_route(root, node, route_classes, source)
422
+ {
423
+ return true;
424
+ }
425
+ false
426
+ }
427
+
428
+ fn constructor_receiver_matches_route(
429
+ root: Node<'_>,
430
+ node: Node<'_>,
431
+ route_classes: &BTreeSet<String>,
432
+ source: &str,
433
+ ) -> bool {
434
+ let Some(type_text) = node
435
+ .child_by_field_name("type")
436
+ .and_then(|type_node| type_node.utf8_text(source.as_bytes()).ok())
437
+ else {
438
+ return false;
439
+ };
440
+ let type_text = strip_whitespace(type_text);
441
+ if let Some(constructor) = node
442
+ .child_by_field_name("constructor")
443
+ .and_then(|constructor| constructor.utf8_text(source.as_bytes()).ok())
444
+ {
445
+ let suffix = format!(".{constructor}");
446
+ if let Some(owner) = type_text.strip_suffix(&suffix) {
447
+ return route_classes.iter().any(|route_class| {
448
+ direct_route_type_text_matches(root, owner, route_class, source)
449
+ });
450
+ }
451
+ }
452
+ route_classes
453
+ .iter()
454
+ .any(|route_class| direct_route_type_text_matches(root, &type_text, route_class, source))
455
+ || route_classes.iter().any(|route_class| {
456
+ direct_named_constructor_type_text_matches_route(root, &type_text, route_class, source)
457
+ })
458
+ }
459
+
460
+ fn direct_route_type_text_matches(
461
+ root: Node<'_>,
462
+ type_text: &str,
463
+ route_class: &str,
464
+ source: &str,
465
+ ) -> bool {
466
+ let type_text = type_text.trim_end_matches('?');
467
+ let base = type_text.split('<').next().unwrap_or(type_text);
468
+ !base.contains('.')
469
+ && base == route_class
470
+ && !route_class_locally_shadowed(root, route_class, source)
471
+ }
472
+
473
+ fn direct_named_constructor_type_text_matches_route(
474
+ root: Node<'_>,
475
+ type_text: &str,
476
+ route_class: &str,
477
+ source: &str,
478
+ ) -> bool {
479
+ if route_class_locally_shadowed(root, route_class, source) {
480
+ return false;
481
+ }
482
+ let Some(rest) = type_text.strip_prefix(route_class) else {
483
+ return false;
484
+ };
485
+ let after_type_arguments = if rest.starts_with('<') {
486
+ let Some(end) = matching_enclosed_end(rest, '<', '>') else {
487
+ return false;
488
+ };
489
+ rest.get(end + 1..).unwrap_or("")
490
+ } else {
491
+ rest
492
+ };
493
+ let Some(constructor) = after_type_arguments.strip_prefix('.') else {
494
+ return false;
495
+ };
496
+ is_identifier_text(constructor)
497
+ }
498
+
499
+ fn direct_constructor_call_matches_route(
500
+ root: Node<'_>,
501
+ text: &str,
502
+ route_class: &str,
503
+ source: &str,
504
+ ) -> bool {
505
+ direct_constructor_call_text(text, route_class)
506
+ && !route_class_locally_shadowed(root, route_class, source)
507
+ }
508
+
509
+ pub(super) fn route_class_locally_shadowed(
510
+ root: Node<'_>,
511
+ route_class: &str,
512
+ source: &str,
513
+ ) -> bool {
514
+ let mut cursor = root.walk();
515
+ root.named_children(&mut cursor).any(|child| {
516
+ local_type_declaration_name(child, source).as_deref() == Some(route_class)
517
+ || import_alias_name(child, source).as_deref() == Some(route_class)
518
+ })
519
+ }
520
+
521
+ fn local_type_declaration_name(node: Node<'_>, source: &str) -> Option<String> {
522
+ match node.kind() {
523
+ "class_declaration"
524
+ | "mixin_declaration"
525
+ | "enum_declaration"
526
+ | "extension_type_declaration" => field_text(node, "name", source),
527
+ "type_alias" => {
528
+ let mut cursor = node.walk();
529
+ node.named_children(&mut cursor)
530
+ .find(|child| matches!(child.kind(), "identifier" | "type_identifier"))
531
+ .and_then(|child| child.utf8_text(source.as_bytes()).ok())
532
+ .map(str::to_owned)
533
+ }
534
+ _ => None,
535
+ }
536
+ }
537
+
538
+ fn import_alias_name(node: Node<'_>, source: &str) -> Option<String> {
539
+ let import = if node.kind() == "library_import" {
540
+ Some(node)
541
+ } else {
542
+ find_first_named_descendant(node, "library_import")
543
+ }?;
544
+ find_first_named_descendant(import, "import_specification")
545
+ .and_then(|specification| field_text(specification, "alias", source))
546
+ }
547
+
548
+ fn direct_constructor_call_text(text: &str, route_class: &str) -> bool {
549
+ let Some(receiver) = unwrap_parenthesized_text(text.trim()) else {
550
+ return false;
551
+ };
552
+ let Some(after_type) = receiver_after_route_type(receiver, route_class) else {
553
+ return false;
554
+ };
555
+ if after_type.starts_with('(') {
556
+ return balanced_enclosed_text(after_type, '(', ')');
557
+ }
558
+ if after_type.starts_with('<')
559
+ && let Some(arguments_start) =
560
+ matching_enclosed_end(after_type, '<', '>').and_then(|end| after_type.get(end + 1..))
561
+ {
562
+ return arguments_start.starts_with('(')
563
+ && balanced_enclosed_text(arguments_start, '(', ')');
564
+ }
565
+ false
566
+ }
567
+
568
+ fn direct_static_member_call_text(text: &str, type_name: &str, member_name: &str) -> bool {
569
+ let Some(receiver) = unwrap_parenthesized_text(text.trim()) else {
570
+ return false;
571
+ };
572
+ let Some(after_type) = receiver_after_route_type(receiver, type_name) else {
573
+ return false;
574
+ };
575
+ let Some(after_dot) = after_type.strip_prefix('.') else {
576
+ return false;
577
+ };
578
+ let Some(args_start) = after_dot.find('(') else {
579
+ return false;
580
+ };
581
+ let method = after_dot[..args_start].split('<').next().unwrap_or("");
582
+ let mut chars = method.chars();
583
+ chars
584
+ .next()
585
+ .is_some_and(|first| first == '_' || first == '$' || first.is_ascii_alphabetic())
586
+ && chars.all(is_identifier_character)
587
+ && method == member_name
588
+ && balanced_enclosed_text(&after_dot[args_start..], '(', ')')
589
+ }
590
+
591
+ fn receiver_after_route_type<'source>(
592
+ receiver: &'source str,
593
+ route_class: &str,
594
+ ) -> Option<&'source str> {
595
+ receiver.strip_prefix(route_class)
596
+ }
597
+
598
+ fn unwrap_parenthesized_text(text: &str) -> Option<&str> {
599
+ let mut current = text;
600
+ while current.starts_with('(') && current.ends_with(')') {
601
+ let end = matching_enclosed_end(current, '(', ')')?;
602
+ if end + 1 != current.len() {
603
+ break;
604
+ }
605
+ current = current.get(1..end)?.trim();
606
+ }
607
+ Some(current)
608
+ }
609
+
610
+ fn balanced_enclosed_text(text: &str, open: char, close: char) -> bool {
611
+ matching_enclosed_end(text, open, close).is_some_and(|end| end + 1 == text.len())
612
+ }
613
+
614
+ fn matching_enclosed_end(text: &str, open: char, close: char) -> Option<usize> {
615
+ let mut chars = text.char_indices();
616
+ if chars.next().is_none_or(|(_, character)| character != open) {
617
+ return None;
618
+ }
619
+ let mut depth = 0usize;
620
+ for (index, character) in text.char_indices() {
621
+ if character == open {
622
+ depth += 1;
623
+ } else if character == close {
624
+ depth = depth.checked_sub(1)?;
625
+ if depth == 0 {
626
+ return Some(index);
627
+ }
628
+ }
629
+ }
630
+ None
631
+ }
632
+
633
+ fn is_identifier_character(character: char) -> bool {
634
+ character == '_' || character == '$' || character.is_ascii_alphanumeric()
635
+ }
636
+
637
+ fn is_identifier_text(text: &str) -> bool {
638
+ let mut chars = text.chars();
639
+ chars
640
+ .next()
641
+ .is_some_and(|first| first == '_' || first == '$' || first.is_ascii_alphabetic())
642
+ && chars.all(is_identifier_character)
643
+ }
644
+
645
+ fn simple_type_name(text: &str) -> String {
646
+ text.trim_end_matches('?')
647
+ .rsplit('.')
648
+ .next()
649
+ .unwrap_or(text)
650
+ .split('<')
651
+ .next()
652
+ .unwrap_or(text)
653
+ .to_owned()
654
+ }
655
+
656
+ fn is_typed_route_navigation_reference(name: &str) -> bool {
657
+ matches!(name, "go" | "push" | "pushReplacement" | "replace")
658
+ }
659
+
660
+ fn strip_method_type_arguments(name: &str) -> &str {
661
+ let Some(start) = name.find('<') else {
662
+ return name;
663
+ };
664
+ let Some(type_arguments) = name.get(start..) else {
665
+ return name;
666
+ };
667
+ if balanced_enclosed_text(type_arguments, '<', '>') {
668
+ &name[..start]
669
+ } else {
670
+ name
671
+ }
672
+ }
673
+
674
+ fn is_typed_go_router_registry(file: &DartFile) -> bool {
675
+ if file.routes.is_empty()
676
+ && !file.references.iter().any(|reference| {
677
+ matches!(
678
+ reference.name.as_str(),
679
+ "TypedGoRoute"
680
+ | "TypedRelativeGoRoute"
681
+ | "TypedShellRoute"
682
+ | "TypedStatefulShellRoute"
683
+ | "TypedStatefulShellBranch"
684
+ )
685
+ })
686
+ {
687
+ return false;
688
+ }
689
+
690
+ file.parts.iter().any(|part| part.uri.ends_with(".g.dart"))
691
+ }
692
+
693
+ fn direct_named_child<'tree>(node: Node<'tree>, kind: &str) -> Option<Node<'tree>> {
694
+ let mut cursor = node.walk();
695
+ node.named_children(&mut cursor)
696
+ .find(|child| child.kind() == kind)
697
+ }
698
+
699
+ fn find_first_named_descendant<'tree>(node: Node<'tree>, kind: &str) -> Option<Node<'tree>> {
700
+ if node.kind() == kind {
701
+ return Some(node);
702
+ }
703
+ let mut cursor = node.walk();
704
+ for child in node.named_children(&mut cursor) {
705
+ if let Some(found) = find_first_named_descendant(child, kind) {
706
+ return Some(found);
707
+ }
708
+ }
709
+ None
710
+ }
711
+
712
+ fn field_text(node: Node<'_>, field: &str, source: &str) -> Option<String> {
713
+ node.child_by_field_name(field)
714
+ .and_then(|child| child.utf8_text(source.as_bytes()).ok())
715
+ .map(str::to_owned)
716
+ }
717
+
718
+ fn strip_whitespace(text: &str) -> String {
719
+ text.chars()
720
+ .filter(|character| !character.is_whitespace())
721
+ .collect()
722
+ }
723
+
724
+ fn visit_named(node: Node<'_>, visitor: &mut impl FnMut(Node<'_>)) {
725
+ visitor(node);
726
+ let mut cursor = node.walk();
727
+ for child in node.named_children(&mut cursor) {
728
+ visit_named(child, visitor);
729
+ }
730
+ }