dart-decimate 0.0.40 → 0.0.42
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 +1 -1
- package/package.json +1 -1
- package/src/dart_parser.rs +510 -47
- package/src/extract/references.rs +134 -1
- package/src/extract/tests.rs +71 -0
- package/src/extract.rs +4 -1
- package/src/symbols/index.rs +9 -0
- package/src/symbols/tests.rs +34 -0
- package/src/symbols.rs +2 -1
- package/src/widgets/unrendered.rs +325 -17
|
@@ -1,6 +1,87 @@
|
|
|
1
1
|
use tree_sitter::Node;
|
|
2
2
|
|
|
3
|
-
use super::{IdentifierReference, Location};
|
|
3
|
+
use super::{DOT_SHORTHAND_QUALIFIER, IdentifierReference, Location};
|
|
4
|
+
|
|
5
|
+
pub(super) fn extract_dot_shorthand_references(source: &str) -> Vec<IdentifierReference> {
|
|
6
|
+
let bytes = source.as_bytes();
|
|
7
|
+
let mut references = Vec::new();
|
|
8
|
+
collect_dot_shorthand_references(source, 0, bytes.len(), &mut references);
|
|
9
|
+
references
|
|
10
|
+
}
|
|
11
|
+
|
|
12
|
+
fn collect_dot_shorthand_references(
|
|
13
|
+
source: &str,
|
|
14
|
+
start: usize,
|
|
15
|
+
end: usize,
|
|
16
|
+
references: &mut Vec<IdentifierReference>,
|
|
17
|
+
) {
|
|
18
|
+
let bytes = source.as_bytes();
|
|
19
|
+
let mut cursor = start;
|
|
20
|
+
while cursor < end {
|
|
21
|
+
if line_comment_start(bytes, cursor) {
|
|
22
|
+
cursor = line_comment_end(bytes, cursor);
|
|
23
|
+
continue;
|
|
24
|
+
}
|
|
25
|
+
if block_comment_start(bytes, cursor) {
|
|
26
|
+
cursor = block_comment_end(bytes, cursor);
|
|
27
|
+
continue;
|
|
28
|
+
}
|
|
29
|
+
if matches!(bytes[cursor], b'r' | b'R') && raw_quoted_segment_start(bytes, cursor).is_some()
|
|
30
|
+
{
|
|
31
|
+
cursor = raw_quoted_segment_end(bytes, cursor);
|
|
32
|
+
continue;
|
|
33
|
+
}
|
|
34
|
+
if matches!(bytes[cursor], b'\'' | b'"') {
|
|
35
|
+
let string_end = quoted_segment_end(bytes, cursor).min(end);
|
|
36
|
+
collect_dot_shorthand_interpolations(source, cursor, string_end, references);
|
|
37
|
+
cursor = string_end;
|
|
38
|
+
continue;
|
|
39
|
+
}
|
|
40
|
+
if bytes[cursor] != b'.' || !crate::dart_parser::is_dot_shorthand_start(bytes, cursor) {
|
|
41
|
+
cursor += 1;
|
|
42
|
+
continue;
|
|
43
|
+
}
|
|
44
|
+
let start = cursor + 1;
|
|
45
|
+
let Some(end) = identifier_end(bytes, start) else {
|
|
46
|
+
cursor += 1;
|
|
47
|
+
continue;
|
|
48
|
+
};
|
|
49
|
+
references.push(IdentifierReference {
|
|
50
|
+
name: source[start..end].to_owned(),
|
|
51
|
+
qualifier: Some(DOT_SHORTHAND_QUALIFIER.to_owned()),
|
|
52
|
+
location: location_at(source, start),
|
|
53
|
+
});
|
|
54
|
+
cursor = end;
|
|
55
|
+
}
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
fn collect_dot_shorthand_interpolations(
|
|
59
|
+
source: &str,
|
|
60
|
+
start: usize,
|
|
61
|
+
end: usize,
|
|
62
|
+
references: &mut Vec<IdentifierReference>,
|
|
63
|
+
) {
|
|
64
|
+
let bytes = source.as_bytes();
|
|
65
|
+
let mut cursor = start;
|
|
66
|
+
while cursor < end {
|
|
67
|
+
let Some(relative) = bytes[cursor..end].iter().position(|byte| *byte == b'$') else {
|
|
68
|
+
return;
|
|
69
|
+
};
|
|
70
|
+
let dollar = cursor + relative;
|
|
71
|
+
cursor = dollar + 1;
|
|
72
|
+
if is_escaped_dollar(bytes, dollar) || bytes.get(cursor) != Some(&b'{') {
|
|
73
|
+
continue;
|
|
74
|
+
}
|
|
75
|
+
let body_start = cursor + 1;
|
|
76
|
+
let Some(body_end) =
|
|
77
|
+
interpolation_body_end(source, body_start).filter(|body_end| *body_end < end)
|
|
78
|
+
else {
|
|
79
|
+
return;
|
|
80
|
+
};
|
|
81
|
+
collect_dot_shorthand_references(source, body_start, body_end, references);
|
|
82
|
+
cursor = body_end + 1;
|
|
83
|
+
}
|
|
84
|
+
}
|
|
4
85
|
|
|
5
86
|
pub(super) fn extract_identifier_references(
|
|
6
87
|
root: Node<'_>,
|
|
@@ -108,6 +189,9 @@ fn collect_string_segment_interpolation_references(
|
|
|
108
189
|
|
|
109
190
|
fn simple_member_qualifier(node: Node<'_>, source: &str) -> Option<String> {
|
|
110
191
|
let parent = node.parent()?;
|
|
192
|
+
if parent.kind() == "static_member_shorthand" {
|
|
193
|
+
return Some(DOT_SHORTHAND_QUALIFIER.to_owned());
|
|
194
|
+
}
|
|
111
195
|
if parent.kind() == "constant_pattern" {
|
|
112
196
|
let text = parent.utf8_text(source.as_bytes()).ok()?;
|
|
113
197
|
let (qualifier, property) = text.rsplit_once('.')?;
|
|
@@ -456,3 +540,52 @@ fn same_node(left: Node<'_>, right: Node<'_>) -> bool {
|
|
|
456
540
|
&& left.start_byte() == right.start_byte()
|
|
457
541
|
&& left.end_byte() == right.end_byte()
|
|
458
542
|
}
|
|
543
|
+
|
|
544
|
+
#[cfg(test)]
|
|
545
|
+
mod tests {
|
|
546
|
+
use super::*;
|
|
547
|
+
|
|
548
|
+
#[test]
|
|
549
|
+
fn dot_shorthand_references_ignore_non_code_and_member_access() {
|
|
550
|
+
let source = r#"
|
|
551
|
+
final values = [.loading, .new(), object.ready, object?.failed];
|
|
552
|
+
final selected = switch (state) { .ready => true, _ => false };
|
|
553
|
+
final returned = return .returned;
|
|
554
|
+
final thrown = throw .thrown;
|
|
555
|
+
final yielded = yield .yielded;
|
|
556
|
+
final matched = case .matched;
|
|
557
|
+
final awaited = await .awaited;
|
|
558
|
+
final constant = const .new<Thing>();
|
|
559
|
+
final label = '${.interpolated}';
|
|
560
|
+
// .commented
|
|
561
|
+
/* .blocked */
|
|
562
|
+
final text = '.quoted';
|
|
563
|
+
final raw = r".raw";
|
|
564
|
+
"#;
|
|
565
|
+
|
|
566
|
+
let references = extract_dot_shorthand_references(source);
|
|
567
|
+
assert_eq!(
|
|
568
|
+
references
|
|
569
|
+
.iter()
|
|
570
|
+
.map(|reference| reference.name.as_str())
|
|
571
|
+
.collect::<Vec<_>>(),
|
|
572
|
+
vec![
|
|
573
|
+
"loading",
|
|
574
|
+
"new",
|
|
575
|
+
"ready",
|
|
576
|
+
"returned",
|
|
577
|
+
"thrown",
|
|
578
|
+
"yielded",
|
|
579
|
+
"matched",
|
|
580
|
+
"awaited",
|
|
581
|
+
"new",
|
|
582
|
+
"interpolated",
|
|
583
|
+
]
|
|
584
|
+
);
|
|
585
|
+
assert!(
|
|
586
|
+
references
|
|
587
|
+
.iter()
|
|
588
|
+
.all(|reference| reference.qualifier.as_deref() == Some(DOT_SHORTHAND_QUALIFIER))
|
|
589
|
+
);
|
|
590
|
+
}
|
|
591
|
+
}
|
package/src/extract/tests.rs
CHANGED
|
@@ -524,6 +524,77 @@ extension type UserId(String value) {
|
|
|
524
524
|
Ok(())
|
|
525
525
|
}
|
|
526
526
|
|
|
527
|
+
#[test]
|
|
528
|
+
fn extracts_dart_313_abbreviated_constructors_with_exact_member_names() -> Result<(), ExtractError>
|
|
529
|
+
{
|
|
530
|
+
let source = r"
|
|
531
|
+
class Box {
|
|
532
|
+
new() {}
|
|
533
|
+
new named() {}
|
|
534
|
+
const new cached();
|
|
535
|
+
final untouched = new Other();
|
|
536
|
+
}
|
|
537
|
+
|
|
538
|
+
class FactoryBox {
|
|
539
|
+
factory() {}
|
|
540
|
+
factory namedFactory() {}
|
|
541
|
+
const factory constFactory() = FactoryBox.cached;
|
|
542
|
+
}
|
|
543
|
+
|
|
544
|
+
mixin class MixinBox {
|
|
545
|
+
new() {}
|
|
546
|
+
new named() {}
|
|
547
|
+
}
|
|
548
|
+
|
|
549
|
+
enum Tone {
|
|
550
|
+
quiet;
|
|
551
|
+
const new();
|
|
552
|
+
}
|
|
553
|
+
|
|
554
|
+
extension type UserId(int value) {
|
|
555
|
+
new() : this(0);
|
|
556
|
+
}
|
|
557
|
+
";
|
|
558
|
+
|
|
559
|
+
let extracted = extract_dart_source("lib/constructors.dart", source)?;
|
|
560
|
+
let members = extracted
|
|
561
|
+
.members
|
|
562
|
+
.iter()
|
|
563
|
+
.map(|member| (member.owner.as_str(), member.kind, member.name.as_str()))
|
|
564
|
+
.collect::<Vec<_>>();
|
|
565
|
+
|
|
566
|
+
for expected in [
|
|
567
|
+
("Box", MemberKind::Constructor, "Box"),
|
|
568
|
+
("Box", MemberKind::Constructor, "named"),
|
|
569
|
+
("Box", MemberKind::Constructor, "cached"),
|
|
570
|
+
("Box", MemberKind::Field, "untouched"),
|
|
571
|
+
("FactoryBox", MemberKind::Constructor, "FactoryBox"),
|
|
572
|
+
("FactoryBox", MemberKind::Constructor, "namedFactory"),
|
|
573
|
+
("FactoryBox", MemberKind::Constructor, "constFactory"),
|
|
574
|
+
("MixinBox", MemberKind::Constructor, "MixinBox"),
|
|
575
|
+
("MixinBox", MemberKind::Constructor, "named"),
|
|
576
|
+
("Tone", MemberKind::Constructor, "Tone"),
|
|
577
|
+
("UserId", MemberKind::Constructor, "UserId"),
|
|
578
|
+
] {
|
|
579
|
+
assert!(members.contains(&expected), "missing member {expected:?}");
|
|
580
|
+
}
|
|
581
|
+
|
|
582
|
+
assert_eq!(
|
|
583
|
+
members
|
|
584
|
+
.iter()
|
|
585
|
+
.filter(|(owner, kind, _)| {
|
|
586
|
+
*kind == MemberKind::Constructor
|
|
587
|
+
&& matches!(
|
|
588
|
+
*owner,
|
|
589
|
+
"Box" | "FactoryBox" | "MixinBox" | "Tone" | "UserId"
|
|
590
|
+
)
|
|
591
|
+
})
|
|
592
|
+
.count(),
|
|
593
|
+
10
|
|
594
|
+
);
|
|
595
|
+
Ok(())
|
|
596
|
+
}
|
|
597
|
+
|
|
527
598
|
#[test]
|
|
528
599
|
fn extracts_identifier_references_without_directive_metadata_or_declaration_names()
|
|
529
600
|
-> Result<(), ExtractError> {
|
package/src/extract.rs
CHANGED
|
@@ -20,7 +20,7 @@ use primary_constructors::{
|
|
|
20
20
|
extract_primary_constructor_identifier_references,
|
|
21
21
|
extract_primary_constructor_signature_references,
|
|
22
22
|
};
|
|
23
|
-
use references::extract_identifier_references;
|
|
23
|
+
use references::{extract_dot_shorthand_references, extract_identifier_references};
|
|
24
24
|
pub use routes::DartRouteDeclaration;
|
|
25
25
|
use routes::extract_route_declarations;
|
|
26
26
|
pub use signatures::SignatureReference;
|
|
@@ -242,6 +242,8 @@ pub struct IdentifierReference {
|
|
|
242
242
|
pub location: Location,
|
|
243
243
|
}
|
|
244
244
|
|
|
245
|
+
pub(crate) const DOT_SHORTHAND_QUALIFIER: &str = "$dot-shorthand";
|
|
246
|
+
|
|
245
247
|
/// Top-level declaration categories extracted in Phase 1.
|
|
246
248
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
|
|
247
249
|
#[serde(rename_all = "kebab-case")]
|
|
@@ -356,6 +358,7 @@ pub fn extract_dart_source(path: impl AsRef<Path>, source: &str) -> Result<DartF
|
|
|
356
358
|
let mut declarations = Vec::new();
|
|
357
359
|
let mut members = Vec::new();
|
|
358
360
|
let mut references = extract_identifier_references(root, parse_source);
|
|
361
|
+
references.extend(extract_dot_shorthand_references(source));
|
|
359
362
|
references.extend(extract_primary_constructor_identifier_references(source));
|
|
360
363
|
sort_identifier_references(&mut references);
|
|
361
364
|
let mut signature_references = extract_signature_references(root, parse_source);
|
package/src/symbols/index.rs
CHANGED
|
@@ -2,6 +2,7 @@ use std::collections::{BTreeMap, BTreeSet};
|
|
|
2
2
|
use std::path::{Path, PathBuf};
|
|
3
3
|
|
|
4
4
|
use crate::ScannedProject;
|
|
5
|
+
use crate::extract::DOT_SHORTHAND_QUALIFIER;
|
|
5
6
|
use crate::graph::normalize_against;
|
|
6
7
|
|
|
7
8
|
use super::{
|
|
@@ -89,6 +90,14 @@ impl SymbolIndex {
|
|
|
89
90
|
})
|
|
90
91
|
}
|
|
91
92
|
|
|
93
|
+
pub(super) fn dot_shorthand_reference_count(
|
|
94
|
+
&self,
|
|
95
|
+
name: &str,
|
|
96
|
+
reachable_files: &BTreeSet<PathBuf>,
|
|
97
|
+
) -> usize {
|
|
98
|
+
self.qualified_reference_count(DOT_SHORTHAND_QUALIFIER, name, reachable_files)
|
|
99
|
+
}
|
|
100
|
+
|
|
92
101
|
pub(super) fn reference_count(&self, name: &str, reachable_files: &BTreeSet<PathBuf>) -> usize {
|
|
93
102
|
self.references_by_name.get(name).map_or(0, |references| {
|
|
94
103
|
references
|
package/src/symbols/tests.rs
CHANGED
|
@@ -270,6 +270,40 @@ fn skips_enum_constants_on_public_api_enums() -> Result<(), Box<dyn std::error::
|
|
|
270
270
|
Ok(())
|
|
271
271
|
}
|
|
272
272
|
|
|
273
|
+
#[test]
|
|
274
|
+
fn counts_native_dot_shorthand_enum_references() -> Result<(), Box<dyn std::error::Error>> {
|
|
275
|
+
let fixture = tempfile::tempdir()?;
|
|
276
|
+
write(&fixture, "pubspec.yaml", "name: app\n")?;
|
|
277
|
+
write(
|
|
278
|
+
&fixture,
|
|
279
|
+
"lib/main.dart",
|
|
280
|
+
r"enum Readiness { loading, signedOut, ready }
|
|
281
|
+
|
|
282
|
+
String label(Readiness readiness) => switch (readiness) {
|
|
283
|
+
.loading => 'loading',
|
|
284
|
+
.signedOut => 'signed-out',
|
|
285
|
+
.ready => 'ready',
|
|
286
|
+
};
|
|
287
|
+
|
|
288
|
+
void main() => print(label(.loading));
|
|
289
|
+
",
|
|
290
|
+
)?;
|
|
291
|
+
let project = scan_project(fixture.path())?;
|
|
292
|
+
let dead_code = find_dead_code(&project.graph, ["lib/main.dart"]);
|
|
293
|
+
|
|
294
|
+
let report = analyze_unused_exports(&project, &dead_code);
|
|
295
|
+
|
|
296
|
+
assert!(
|
|
297
|
+
report
|
|
298
|
+
.unused_members
|
|
299
|
+
.iter()
|
|
300
|
+
.all(|unused| unused.owner != "Readiness"),
|
|
301
|
+
"{:?}",
|
|
302
|
+
report.unused_members
|
|
303
|
+
);
|
|
304
|
+
Ok(())
|
|
305
|
+
}
|
|
306
|
+
|
|
273
307
|
#[test]
|
|
274
308
|
fn member_references_are_scoped_to_dart_library_parts() -> Result<(), Box<dyn std::error::Error>> {
|
|
275
309
|
let fixture = tempfile::tempdir()?;
|
package/src/symbols.rs
CHANGED
|
@@ -358,7 +358,8 @@ fn unused_member_from_declaration(
|
|
|
358
358
|
&indexed.member.owner,
|
|
359
359
|
&indexed.member.name,
|
|
360
360
|
reachable_files,
|
|
361
|
-
) + index.
|
|
361
|
+
) + index.dot_shorthand_reference_count(&indexed.member.name, reachable_files)
|
|
362
|
+
+ index.qualified_reference_count(&indexed.member.owner, "values", reachable_files)
|
|
362
363
|
} else {
|
|
363
364
|
let library = index.library_path(&indexed.path);
|
|
364
365
|
index.library_reference_count(&indexed.member.name, library, reachable_files)
|