dart-decimate 0.0.76 → 0.0.78
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 +8 -8
- package/package.json +2 -2
- package/src/boundaries.rs +1 -9
- package/src/cli/analyze.rs +33 -3
- package/src/cli/error.rs +16 -0
- package/src/cli/list_run.rs +3 -1
- package/src/cli/scope_args.rs +14 -3
- package/src/config.rs +12 -8
- package/src/dart_parser.rs +100 -9
- package/src/dependencies/analyze.rs +4 -3
- package/src/dependencies/discovery.rs +10 -2
- package/src/dependencies/flutter_usage.rs +4 -0
- package/src/dependencies/tests.rs +5 -5
- package/src/dependencies/usage.rs +0 -9
- package/src/dependencies.rs +12 -7
- package/src/dupes/declarations.rs +1 -2
- package/src/dupes.rs +1 -10
- package/src/explain/misc.rs +1 -1
- package/src/explain.rs +1 -1
- package/src/extract/members.rs +24 -15
- package/src/extract/tests.rs +89 -0
- package/src/extract.rs +51 -15
- package/src/graph.rs +9 -0
- package/src/lib.rs +3 -2
- package/src/output/duplication_findings.rs +1 -2
- package/src/output/human.rs +7 -2
- package/src/output/human_details.rs +6 -0
- package/src/output/next_steps.rs +111 -0
- package/src/output/route_cycle/aliases.rs +1 -2
- package/src/output/route_cycle/wrappers.rs +1 -2
- package/src/output/types.rs +2 -0
- package/src/output.rs +27 -5
- package/src/outside/loader.rs +133 -0
- package/src/outside/loader_tests.rs +136 -0
- package/src/outside/resolver.rs +484 -0
- package/src/outside/tests.rs +242 -0
- package/src/outside.rs +186 -0
- package/src/package_map.rs +30 -1
- package/src/report_schema.rs +1 -0
- package/src/routes.rs +2 -0
- package/src/scan.rs +24 -3
- package/src/security/detect/process_arguments.rs +106 -0
- package/src/security/detect.rs +98 -40
- package/src/symbols/extensions.rs +42 -27
- package/src/symbols/path_filters.rs +10 -1
- package/src/symbols/tests.rs +15 -0
- package/src/symbols.rs +489 -67
- package/src/trace.rs +6 -5
- package/src/widgets/reads.rs +4 -8
- package/src/widgets/resolution.rs +63 -10
- package/src/workspace_scope.rs +1 -10
package/src/output.rs
CHANGED
|
@@ -173,11 +173,7 @@ pub fn build_json_report(project: &ScannedProject, results: &AnalysisResults) ->
|
|
|
173
173
|
);
|
|
174
174
|
let security =
|
|
175
175
|
json_security_inventories(&project.root, results.security.as_ref(), scope.as_ref());
|
|
176
|
-
let next_steps =
|
|
177
|
-
Vec::new()
|
|
178
|
-
} else {
|
|
179
|
-
next_steps(&project.root, results)
|
|
180
|
-
};
|
|
176
|
+
let next_steps = report_next_steps(project, results, scope.is_some());
|
|
181
177
|
if scope.is_some() {
|
|
182
178
|
apply_health_inventory_summary(
|
|
183
179
|
&mut summary,
|
|
@@ -394,6 +390,28 @@ fn report_findings(
|
|
|
394
390
|
findings
|
|
395
391
|
}
|
|
396
392
|
|
|
393
|
+
fn report_next_steps(
|
|
394
|
+
project: &ScannedProject,
|
|
395
|
+
results: &AnalysisResults,
|
|
396
|
+
scoped: bool,
|
|
397
|
+
) -> Vec<NextStep> {
|
|
398
|
+
if project.scope.is_some() {
|
|
399
|
+
return next_steps(&project.root, results)
|
|
400
|
+
.into_iter()
|
|
401
|
+
.filter(|step| {
|
|
402
|
+
matches!(
|
|
403
|
+
step.id.as_str(),
|
|
404
|
+
"read-outside-types" | "generate-missing-import"
|
|
405
|
+
)
|
|
406
|
+
})
|
|
407
|
+
.collect();
|
|
408
|
+
}
|
|
409
|
+
if scoped {
|
|
410
|
+
return Vec::new();
|
|
411
|
+
}
|
|
412
|
+
next_steps(&project.root, results)
|
|
413
|
+
}
|
|
414
|
+
|
|
397
415
|
fn report_summary(
|
|
398
416
|
project: &ScannedProject,
|
|
399
417
|
results: &AnalysisResults,
|
|
@@ -473,6 +491,10 @@ fn apply_cleanup_summary(
|
|
|
473
491
|
summary.private_type_leaks = kind_count(findings, FindingKind::PrivateTypeLeak);
|
|
474
492
|
summary.unused_enum_members = kind_count(findings, FindingKind::UnusedEnumMember);
|
|
475
493
|
summary.unused_class_members = kind_count(findings, FindingKind::UnusedClassMember);
|
|
494
|
+
summary.outside_types_unread = results
|
|
495
|
+
.symbols
|
|
496
|
+
.as_ref()
|
|
497
|
+
.map_or(0, |report| report.outside_types_unread);
|
|
476
498
|
summary.duplicate_exports = kind_count(findings, FindingKind::DuplicateExport);
|
|
477
499
|
summary.route_collisions = kind_count(findings, FindingKind::RouteCollision);
|
|
478
500
|
summary.mixed_go_router_styles = kind_count(findings, FindingKind::MixedGoRouterStyle);
|
|
@@ -0,0 +1,133 @@
|
|
|
1
|
+
use std::cell::RefCell;
|
|
2
|
+
use std::collections::{BTreeMap, BTreeSet};
|
|
3
|
+
use std::fs;
|
|
4
|
+
use std::path::{Path, PathBuf};
|
|
5
|
+
use std::rc::Rc;
|
|
6
|
+
|
|
7
|
+
use rayon::prelude::*;
|
|
8
|
+
|
|
9
|
+
use crate::DartFile;
|
|
10
|
+
use crate::extract::extract_dart_outline;
|
|
11
|
+
|
|
12
|
+
pub(crate) enum Outline {
|
|
13
|
+
Missing,
|
|
14
|
+
Unparsed,
|
|
15
|
+
Skipped,
|
|
16
|
+
Read(Rc<DartFile>),
|
|
17
|
+
}
|
|
18
|
+
|
|
19
|
+
pub(crate) type SharedLoader = Rc<RefCell<OutlineLoader>>;
|
|
20
|
+
|
|
21
|
+
#[derive(Default)]
|
|
22
|
+
pub(crate) struct OutlineLoader {
|
|
23
|
+
entries: BTreeMap<PathBuf, Entry>,
|
|
24
|
+
}
|
|
25
|
+
|
|
26
|
+
enum Entry {
|
|
27
|
+
Missing,
|
|
28
|
+
Scanned(Scanned),
|
|
29
|
+
}
|
|
30
|
+
|
|
31
|
+
struct Scanned {
|
|
32
|
+
forwards: bool,
|
|
33
|
+
type_names: BTreeSet<String>,
|
|
34
|
+
parsed: Option<Result<Rc<DartFile>, ()>>,
|
|
35
|
+
}
|
|
36
|
+
|
|
37
|
+
struct Built {
|
|
38
|
+
forwards: bool,
|
|
39
|
+
type_names: BTreeSet<String>,
|
|
40
|
+
parsed: Option<Result<DartFile, ()>>,
|
|
41
|
+
}
|
|
42
|
+
|
|
43
|
+
impl OutlineLoader {
|
|
44
|
+
pub(crate) fn prefetch(&mut self, paths: &[PathBuf], wanted: &str) {
|
|
45
|
+
let missing = paths
|
|
46
|
+
.iter()
|
|
47
|
+
.filter(|path| !self.entries.contains_key(*path))
|
|
48
|
+
.collect::<Vec<_>>();
|
|
49
|
+
let built = missing
|
|
50
|
+
.par_iter()
|
|
51
|
+
.map(|path| (*path, build(path, wanted)))
|
|
52
|
+
.collect::<Vec<_>>();
|
|
53
|
+
for (path, built) in built {
|
|
54
|
+
self.entries.insert(path.clone(), entry_from(built));
|
|
55
|
+
}
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
pub(crate) fn load(&mut self, path: &Path, wanted: &str) -> Outline {
|
|
59
|
+
if !self.entries.contains_key(path) {
|
|
60
|
+
self.entries
|
|
61
|
+
.insert(path.to_path_buf(), entry_from(build(path, wanted)));
|
|
62
|
+
}
|
|
63
|
+
let Some(Entry::Scanned(scanned)) = self.entries.get_mut(path) else {
|
|
64
|
+
return Outline::Missing;
|
|
65
|
+
};
|
|
66
|
+
if scanned.parsed.is_none() {
|
|
67
|
+
if !scanned.forwards && !scanned.type_names.contains(wanted) {
|
|
68
|
+
return Outline::Skipped;
|
|
69
|
+
}
|
|
70
|
+
let Ok(source) = fs::read_to_string(path) else {
|
|
71
|
+
return Outline::Missing;
|
|
72
|
+
};
|
|
73
|
+
scanned.parsed = Some(parse(path, &source).map(Rc::new));
|
|
74
|
+
}
|
|
75
|
+
match &scanned.parsed {
|
|
76
|
+
Some(Ok(file)) => Outline::Read(Rc::clone(file)),
|
|
77
|
+
_ => Outline::Unparsed,
|
|
78
|
+
}
|
|
79
|
+
}
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
fn build(path: &Path, wanted: &str) -> Option<Built> {
|
|
83
|
+
let source = fs::read_to_string(path).ok()?;
|
|
84
|
+
let forwards = forwards_libraries(&source);
|
|
85
|
+
let type_names = declared_type_names(&source);
|
|
86
|
+
let parsed = (forwards || type_names.contains(wanted)).then(|| parse(path, &source));
|
|
87
|
+
Some(Built {
|
|
88
|
+
forwards,
|
|
89
|
+
type_names,
|
|
90
|
+
parsed,
|
|
91
|
+
})
|
|
92
|
+
}
|
|
93
|
+
|
|
94
|
+
fn entry_from(built: Option<Built>) -> Entry {
|
|
95
|
+
built.map_or(Entry::Missing, |built| {
|
|
96
|
+
Entry::Scanned(Scanned {
|
|
97
|
+
forwards: built.forwards,
|
|
98
|
+
type_names: built.type_names,
|
|
99
|
+
parsed: built.parsed.map(|parsed| parsed.map(Rc::new)),
|
|
100
|
+
})
|
|
101
|
+
})
|
|
102
|
+
}
|
|
103
|
+
|
|
104
|
+
fn parse(path: &Path, source: &str) -> Result<DartFile, ()> {
|
|
105
|
+
extract_dart_outline(path, source).map_err(|_| ())
|
|
106
|
+
}
|
|
107
|
+
|
|
108
|
+
fn forwards_libraries(source: &str) -> bool {
|
|
109
|
+
source.lines().any(|line| {
|
|
110
|
+
let line = line.trim_start();
|
|
111
|
+
["export", "part"].iter().any(|keyword| {
|
|
112
|
+
line.strip_prefix(keyword).is_some_and(|rest| {
|
|
113
|
+
rest.trim_start().starts_with(['\'', '"']) && rest.starts_with(char::is_whitespace)
|
|
114
|
+
})
|
|
115
|
+
})
|
|
116
|
+
})
|
|
117
|
+
}
|
|
118
|
+
|
|
119
|
+
fn declared_type_names(source: &str) -> BTreeSet<String> {
|
|
120
|
+
let mut names = BTreeSet::new();
|
|
121
|
+
for keyword in ["class", "mixin", "typedef"] {
|
|
122
|
+
for (index, _) in source.match_indices(keyword) {
|
|
123
|
+
let rest = source[index + keyword.len()..].trim_start();
|
|
124
|
+
let end = rest
|
|
125
|
+
.find(|character: char| !(character.is_alphanumeric() || "_$".contains(character)))
|
|
126
|
+
.unwrap_or(rest.len());
|
|
127
|
+
if end > 0 {
|
|
128
|
+
names.insert(rest[..end].to_owned());
|
|
129
|
+
}
|
|
130
|
+
}
|
|
131
|
+
}
|
|
132
|
+
names
|
|
133
|
+
}
|
|
@@ -0,0 +1,136 @@
|
|
|
1
|
+
use std::fs;
|
|
2
|
+
|
|
3
|
+
use crate::dart_parser::track_parse_count;
|
|
4
|
+
|
|
5
|
+
use super::loader::{Outline, OutlineLoader};
|
|
6
|
+
|
|
7
|
+
#[test]
|
|
8
|
+
fn loader_parses_only_files_that_declare_the_wanted_type_or_forward_others()
|
|
9
|
+
-> Result<(), Box<dyn std::error::Error>> {
|
|
10
|
+
let folder = tempfile::tempdir()?;
|
|
11
|
+
let declares = folder.path().join("declares.dart");
|
|
12
|
+
let forwards = folder.path().join("forwards.dart");
|
|
13
|
+
let other = folder.path().join("other.dart");
|
|
14
|
+
fs::write(
|
|
15
|
+
&declares,
|
|
16
|
+
"abstract class Wanted<T> {\n void hook() {}\n}\n",
|
|
17
|
+
)?;
|
|
18
|
+
fs::write(
|
|
19
|
+
&forwards,
|
|
20
|
+
"library forwards;\nexport 'declares.dart' show Wanted;\npart 'extra.dart';\n",
|
|
21
|
+
)?;
|
|
22
|
+
fs::write(&other, "class Unrelated {}\nmixin Helper {}\n")?;
|
|
23
|
+
let other_parses = track_parse_count(&other);
|
|
24
|
+
let mut loader = OutlineLoader::default();
|
|
25
|
+
|
|
26
|
+
let Outline::Read(declaring_file) = loader.load(&declares, "Wanted") else {
|
|
27
|
+
return Err("declaring file not read".into());
|
|
28
|
+
};
|
|
29
|
+
let Outline::Read(forwarding_file) = loader.load(&forwards, "Wanted") else {
|
|
30
|
+
return Err("forwarding file not read".into());
|
|
31
|
+
};
|
|
32
|
+
|
|
33
|
+
assert_eq!(declaring_file.declarations[0].name, "Wanted");
|
|
34
|
+
assert_eq!(declaring_file.members[0].name, "hook");
|
|
35
|
+
assert_eq!(forwarding_file.exports[0].uri, "declares.dart");
|
|
36
|
+
assert_eq!(forwarding_file.parts[0].uri, "extra.dart");
|
|
37
|
+
assert!(matches!(loader.load(&other, "Wanted"), Outline::Skipped));
|
|
38
|
+
assert_eq!(other_parses.count(), 0);
|
|
39
|
+
assert!(matches!(loader.load(&other, "Helper"), Outline::Read(_)));
|
|
40
|
+
assert_eq!(other_parses.count(), 1);
|
|
41
|
+
assert!(matches!(loader.load(&other, "Unrelated"), Outline::Read(_)));
|
|
42
|
+
assert_eq!(other_parses.count(), 1);
|
|
43
|
+
|
|
44
|
+
Ok(())
|
|
45
|
+
}
|
|
46
|
+
|
|
47
|
+
#[test]
|
|
48
|
+
fn loader_reports_files_it_cannot_read_or_parse() -> Result<(), Box<dyn std::error::Error>> {
|
|
49
|
+
let folder = tempfile::tempdir()?;
|
|
50
|
+
let broken = folder.path().join("broken.dart");
|
|
51
|
+
fs::write(&broken, "class Wanted {{{ export 'a.dart';\n")?;
|
|
52
|
+
let mut loader = OutlineLoader::default();
|
|
53
|
+
|
|
54
|
+
assert!(matches!(
|
|
55
|
+
loader.load(&folder.path().join("missing.dart"), "Wanted"),
|
|
56
|
+
Outline::Missing
|
|
57
|
+
));
|
|
58
|
+
assert!(matches!(loader.load(&broken, "Wanted"), Outline::Unparsed));
|
|
59
|
+
assert!(matches!(loader.load(&broken, "Wanted"), Outline::Unparsed));
|
|
60
|
+
|
|
61
|
+
Ok(())
|
|
62
|
+
}
|
|
63
|
+
|
|
64
|
+
#[test]
|
|
65
|
+
fn loader_finds_declarations_that_modifiers_and_line_breaks_separate()
|
|
66
|
+
-> Result<(), Box<dyn std::error::Error>> {
|
|
67
|
+
let folder = tempfile::tempdir()?;
|
|
68
|
+
let path = folder.path().join("types.dart");
|
|
69
|
+
fs::write(
|
|
70
|
+
&path,
|
|
71
|
+
"abstract interface class Face {}\nmixin class Both {}\ntypedef Alias = Face;\nclass\n Spread {}\n",
|
|
72
|
+
)?;
|
|
73
|
+
|
|
74
|
+
for name in ["Face", "Both", "Alias", "Spread"] {
|
|
75
|
+
let mut loader = OutlineLoader::default();
|
|
76
|
+
assert!(
|
|
77
|
+
matches!(loader.load(&path, name), Outline::Read(_)),
|
|
78
|
+
"{name}"
|
|
79
|
+
);
|
|
80
|
+
}
|
|
81
|
+
assert!(matches!(
|
|
82
|
+
OutlineLoader::default().load(&path, "Missing"),
|
|
83
|
+
Outline::Skipped
|
|
84
|
+
));
|
|
85
|
+
|
|
86
|
+
Ok(())
|
|
87
|
+
}
|
|
88
|
+
|
|
89
|
+
#[test]
|
|
90
|
+
fn prefetch_loads_many_files_at_once_and_load_reuses_them() -> Result<(), Box<dyn std::error::Error>>
|
|
91
|
+
{
|
|
92
|
+
let folder = tempfile::tempdir()?;
|
|
93
|
+
let forwarding = folder.path().join("forwarding.dart");
|
|
94
|
+
let declaring = folder.path().join("declaring.dart");
|
|
95
|
+
let other = folder.path().join("other.dart");
|
|
96
|
+
let missing = folder.path().join("missing.dart");
|
|
97
|
+
fs::write(&forwarding, "export 'declaring.dart';\n")?;
|
|
98
|
+
fs::write(&declaring, "class Wanted {}\n")?;
|
|
99
|
+
fs::write(&other, "class Unrelated {}\n")?;
|
|
100
|
+
let forwarding_parses = track_parse_count(&forwarding);
|
|
101
|
+
let declaring_parses = track_parse_count(&declaring);
|
|
102
|
+
let other_parses = track_parse_count(&other);
|
|
103
|
+
let parses = || {
|
|
104
|
+
[
|
|
105
|
+
forwarding_parses.count(),
|
|
106
|
+
declaring_parses.count(),
|
|
107
|
+
other_parses.count(),
|
|
108
|
+
]
|
|
109
|
+
};
|
|
110
|
+
let mut loader = OutlineLoader::default();
|
|
111
|
+
|
|
112
|
+
loader.prefetch(
|
|
113
|
+
&[
|
|
114
|
+
forwarding.clone(),
|
|
115
|
+
declaring.clone(),
|
|
116
|
+
other.clone(),
|
|
117
|
+
missing.clone(),
|
|
118
|
+
],
|
|
119
|
+
"Wanted",
|
|
120
|
+
);
|
|
121
|
+
|
|
122
|
+
assert_eq!(parses(), [1, 1, 0]);
|
|
123
|
+
assert!(matches!(
|
|
124
|
+
loader.load(&forwarding, "Wanted"),
|
|
125
|
+
Outline::Read(_)
|
|
126
|
+
));
|
|
127
|
+
assert!(matches!(
|
|
128
|
+
loader.load(&declaring, "Wanted"),
|
|
129
|
+
Outline::Read(_)
|
|
130
|
+
));
|
|
131
|
+
assert!(matches!(loader.load(&other, "Wanted"), Outline::Skipped));
|
|
132
|
+
assert!(matches!(loader.load(&missing, "Wanted"), Outline::Missing));
|
|
133
|
+
assert_eq!(parses(), [1, 1, 0]);
|
|
134
|
+
|
|
135
|
+
Ok(())
|
|
136
|
+
}
|