dart-decimate 0.0.77 → 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.
Files changed (53) hide show
  1. package/Cargo.lock +1 -1
  2. package/Cargo.toml +1 -1
  3. package/README.md +8 -8
  4. package/package.json +2 -2
  5. package/src/boundaries.rs +1 -9
  6. package/src/cli/analyze.rs +33 -3
  7. package/src/cli/error.rs +16 -0
  8. package/src/cli/list_run.rs +3 -1
  9. package/src/cli/scope_args.rs +14 -3
  10. package/src/config.rs +12 -8
  11. package/src/dart_parser.rs +100 -9
  12. package/src/dependencies/analyze.rs +4 -3
  13. package/src/dependencies/discovery.rs +10 -2
  14. package/src/dependencies/flutter_usage.rs +4 -0
  15. package/src/dependencies/tests.rs +5 -5
  16. package/src/dependencies/usage.rs +0 -9
  17. package/src/dependencies.rs +12 -7
  18. package/src/dupes/declarations.rs +1 -2
  19. package/src/dupes.rs +1 -10
  20. package/src/explain/misc.rs +1 -1
  21. package/src/explain.rs +1 -1
  22. package/src/extract/members.rs +24 -15
  23. package/src/extract/tests.rs +89 -0
  24. package/src/extract.rs +51 -15
  25. package/src/graph.rs +9 -0
  26. package/src/lib.rs +3 -2
  27. package/src/output/duplication_findings.rs +1 -2
  28. package/src/output/human.rs +7 -2
  29. package/src/output/human_details.rs +6 -0
  30. package/src/output/next_steps.rs +111 -0
  31. package/src/output/route_cycle/aliases.rs +1 -2
  32. package/src/output/route_cycle/wrappers.rs +1 -2
  33. package/src/output/types.rs +2 -0
  34. package/src/output.rs +27 -5
  35. package/src/outside/loader.rs +133 -0
  36. package/src/outside/loader_tests.rs +136 -0
  37. package/src/outside/resolver.rs +484 -0
  38. package/src/outside/tests.rs +242 -0
  39. package/src/outside.rs +186 -0
  40. package/src/package_map.rs +30 -1
  41. package/src/report_schema.rs +1 -0
  42. package/src/routes.rs +2 -0
  43. package/src/scan.rs +24 -3
  44. package/src/security/detect/process_arguments.rs +106 -0
  45. package/src/security/detect.rs +98 -40
  46. package/src/symbols/extensions.rs +42 -27
  47. package/src/symbols/path_filters.rs +10 -1
  48. package/src/symbols/tests.rs +15 -0
  49. package/src/symbols.rs +489 -67
  50. package/src/trace.rs +6 -5
  51. package/src/widgets/reads.rs +4 -8
  52. package/src/widgets/resolution.rs +63 -10
  53. 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 = if scope.is_some() {
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
+ }