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.
- package/Cargo.lock +1 -1
- package/Cargo.toml +1 -1
- package/README.md +13 -4
- package/package.json +1 -1
- package/src/dupes/declarations.rs +512 -0
- package/src/dupes/packages.rs +143 -1
- package/src/dupes/tests.rs +170 -0
- package/src/dupes.rs +54 -21
- package/src/output/graph_findings.rs +51 -17
- package/src/output/route_cycle/aliases.rs +875 -0
- package/src/output/route_cycle/navigation.rs +1005 -0
- package/src/output/route_cycle/receivers.rs +41 -0
- package/src/output/route_cycle/state_context.rs +209 -0
- package/src/output/route_cycle/tests.rs +175 -0
- package/src/output/route_cycle.rs +730 -0
- package/src/output.rs +2 -1
- package/src/widgets/forwarding.rs +684 -0
- package/src/widgets/patterns.rs +2595 -0
- package/src/widgets/reads.rs +616 -0
- package/src/widgets/tests.rs +1837 -55
- package/src/widgets/unrendered.rs +150 -0
- package/src/widgets.rs +25 -93
|
@@ -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
|
+
}
|