dart-decimate 0.0.14 → 0.0.15

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 CHANGED
@@ -102,7 +102,7 @@ checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
102
102
 
103
103
  [[package]]
104
104
  name = "dart-decimate"
105
- version = "0.0.14"
105
+ version = "0.0.15"
106
106
  dependencies = [
107
107
  "clap",
108
108
  "glob",
package/Cargo.toml CHANGED
@@ -1,6 +1,6 @@
1
1
  [package]
2
2
  name = "dart-decimate"
3
- version = "0.0.14"
3
+ version = "0.0.15"
4
4
  edition = "2024"
5
5
  rust-version = "1.85"
6
6
  description = "Rust-native codebase intelligence for Dart and Flutter module graphs."
package/README.md CHANGED
@@ -91,7 +91,7 @@ Add this to `package.json` if you want a short project command:
91
91
  "dart-decimate": "dart-decimate json ."
92
92
  },
93
93
  "devDependencies": {
94
- "dart-decimate": "^0.0.14"
94
+ "dart-decimate": "^0.0.15"
95
95
  }
96
96
  }
97
97
  ```
@@ -667,7 +667,7 @@ This repository forbids `unsafe_code`.
667
667
 
668
668
  ## Release Flow
669
669
 
670
- Current version: `0.0.14`.
670
+ Current version: `0.0.15`.
671
671
 
672
672
  After the first public release, changes should go through pull requests. Every
673
673
  PR to `main` must bump both `Cargo.toml` and `package.json` above the base
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "dart-decimate",
3
- "version": "0.0.14",
3
+ "version": "0.0.15",
4
4
  "description": "Rust-native codebase intelligence for Dart and Flutter module graphs.",
5
5
  "license": "MIT",
6
6
  "bin": {
@@ -1,9 +1,11 @@
1
- use std::collections::BTreeMap;
1
+ use std::collections::{BTreeMap, BTreeSet};
2
2
  use std::path::{Path, PathBuf};
3
3
 
4
4
  use crate::dependency_scripts::package_used_in_tooling;
5
5
  use crate::generated::is_generated_dart_path;
6
- use crate::{DependencyKind, Location, scan::ScannedProject};
6
+ use crate::graph::resolve_local_uri;
7
+ use crate::package_map::PackageMap;
8
+ use crate::{DartFile, DependencyKind, Location, extract_dart_file, scan::ScannedProject};
7
9
 
8
10
  use super::codegen::codegen_dependencies_for_file;
9
11
  use super::usage::DependencyUsage;
@@ -31,7 +33,8 @@ pub fn analyze_dependency_hygiene(
31
33
  project: &ScannedProject,
32
34
  ) -> Result<DependencyHygieneReport, DependencyHygieneError> {
33
35
  let packages = discover_packages(&project.root)?;
34
- let mut imports = collect_import_usage(project, &packages);
36
+ let generated_runtime_files = reachable_generated_runtime_files(project, &packages)?;
37
+ let mut imports = collect_import_usage(project, &packages, &generated_runtime_files);
35
38
  let mut unused_dependencies = unused_dependencies(&packages, &imports.used_by_package);
36
39
 
37
40
  sort_unused_dependencies(&mut unused_dependencies);
@@ -48,7 +51,11 @@ pub fn analyze_dependency_hygiene(
48
51
  })
49
52
  }
50
53
 
51
- fn collect_import_usage(project: &ScannedProject, packages: &[PubPackage]) -> ImportUsage {
54
+ fn collect_import_usage(
55
+ project: &ScannedProject,
56
+ packages: &[PubPackage],
57
+ generated_runtime_files: &[DartFile],
58
+ ) -> ImportUsage {
52
59
  let mut usage = ImportUsage::default();
53
60
  for file in &project.files {
54
61
  let Some(owner) = owning_package(packages, &file.path) else {
@@ -80,9 +87,76 @@ fn collect_import_usage(project: &ScannedProject, packages: &[PubPackage]) -> Im
80
87
  }
81
88
  }
82
89
  }
90
+ for file in generated_runtime_files {
91
+ let Some(owner) = owning_package(packages, &file.path) else {
92
+ continue;
93
+ };
94
+ for specifier in file
95
+ .imports
96
+ .iter()
97
+ .map(|import| import.uri.as_str())
98
+ .chain(file.exports.iter().map(|export| export.uri.as_str()))
99
+ {
100
+ let Some(dependency) = package_name(specifier) else {
101
+ continue;
102
+ };
103
+ if dependency != owner.name {
104
+ record_dependency_usage(&mut usage, owner, &file.path, &dependency);
105
+ }
106
+ }
107
+ }
83
108
  usage
84
109
  }
85
110
 
111
+ fn reachable_generated_runtime_files(
112
+ project: &ScannedProject,
113
+ packages: &[PubPackage],
114
+ ) -> Result<Vec<DartFile>, DependencyHygieneError> {
115
+ let package_map = PackageMap::discover(&project.root)?;
116
+ let mut known_paths = project
117
+ .files
118
+ .iter()
119
+ .map(|file| file.path.clone())
120
+ .collect::<BTreeSet<_>>();
121
+ let mut frontier = project
122
+ .files
123
+ .iter()
124
+ .filter(|file| {
125
+ owning_package(packages, &file.path)
126
+ .is_some_and(|owner| !super::allows_dev_dependency(&owner.root, &file.path))
127
+ })
128
+ .cloned()
129
+ .collect::<Vec<_>>();
130
+ let mut generated = Vec::new();
131
+
132
+ while let Some(file) = frontier.pop() {
133
+ for specifier in file
134
+ .imports
135
+ .iter()
136
+ .map(|import| import.uri.as_str())
137
+ .chain(file.exports.iter().map(|export| export.uri.as_str()))
138
+ {
139
+ let Some(target) =
140
+ resolve_local_uri(&project.root, &package_map, &file.path, specifier)
141
+ else {
142
+ continue;
143
+ };
144
+ if !target.local
145
+ || !target.path.is_file()
146
+ || !is_generated_dart_path(&target.path)
147
+ || !known_paths.insert(target.path.clone())
148
+ {
149
+ continue;
150
+ }
151
+ let parsed = extract_dart_file(&target.path)?;
152
+ frontier.push(parsed.clone());
153
+ generated.push(parsed);
154
+ }
155
+ }
156
+ generated.sort_by(|left, right| left.path.cmp(&right.path));
157
+ Ok(generated)
158
+ }
159
+
86
160
  fn record_directive(
87
161
  usage: &mut ImportUsage,
88
162
  owner: &PubPackage,
@@ -110,13 +184,7 @@ fn record_directive(
110
184
  });
111
185
  }
112
186
 
113
- usage
114
- .used_by_package
115
- .entry(owner.root.clone())
116
- .or_default()
117
- .entry(dependency.clone())
118
- .or_default()
119
- .record(&owner.root, file_path);
187
+ record_dependency_usage(usage, owner, file_path, &dependency);
120
188
 
121
189
  if !owner.declares_dependency_for_path(&dependency, file_path)
122
190
  && !is_known_generated_internal_import(file_path, specifier)
@@ -137,6 +205,21 @@ fn record_directive(
137
205
  }
138
206
  }
139
207
 
208
+ fn record_dependency_usage(
209
+ usage: &mut ImportUsage,
210
+ owner: &PubPackage,
211
+ file_path: &Path,
212
+ dependency: &str,
213
+ ) {
214
+ usage
215
+ .used_by_package
216
+ .entry(owner.root.clone())
217
+ .or_default()
218
+ .entry(dependency.to_owned())
219
+ .or_default()
220
+ .record(&owner.root, file_path);
221
+ }
222
+
140
223
  fn is_known_generated_internal_import(file_path: &Path, specifier: &str) -> bool {
141
224
  is_generated_dart_path(file_path) && matches!(specifier, "package:slang/generated.dart")
142
225
  }
@@ -7,7 +7,7 @@ use serde_yaml_ng::{Mapping, Value};
7
7
  use thiserror::Error;
8
8
 
9
9
  use crate::graph::normalize_path;
10
- use crate::{DependencyKind, Location};
10
+ use crate::{DependencyKind, ExtractError, GraphError, Location};
11
11
 
12
12
  mod analyze;
13
13
  mod codegen;
@@ -145,6 +145,12 @@ impl DependencySection {
145
145
  /// Errors returned while analyzing pub dependency hygiene.
146
146
  #[derive(Debug, Error)]
147
147
  pub enum DependencyHygieneError {
148
+ /// Local package resolution failed while following a generated runtime file.
149
+ #[error(transparent)]
150
+ Graph(#[from] GraphError),
151
+ /// A reachable generated runtime file could not be parsed.
152
+ #[error(transparent)]
153
+ Extract(#[from] ExtractError),
148
154
  /// A directory could not be read.
149
155
  #[error("failed to read directory {path}: {source}")]
150
156
  ReadDir {
@@ -1,8 +1,8 @@
1
1
  use tree_sitter::Node;
2
2
 
3
3
  use super::{
4
- balanced_enclosed_text, class_extends_state, direct_constructor_call_text, direct_named_child,
5
- direct_static_member_call_text, is_identifier_character, simple_type_name,
4
+ argument_list, balanced_enclosed_text, class_extends_state, direct_constructor_call_text,
5
+ direct_named_child, direct_static_member_call_text, is_identifier_character, simple_type_name,
6
6
  strip_constructor_keyword_prefix, strip_whitespace, unwrap_parenthesized_text,
7
7
  };
8
8
 
@@ -42,10 +42,8 @@ pub(super) fn route_extension_navigation_has_context_argument(
42
42
  ) -> bool {
43
43
  first_positional_argument(arguments)
44
44
  .and_then(|argument| argument.utf8_text(source.as_bytes()).ok())
45
- .and_then(navigation_target_name)
46
- .is_some_and(|target| {
47
- target_resolves_to_navigation_type(root, site, &target, &[BUILD_CONTEXT], source)
48
- })
45
+ .and_then(|target| navigation_expression_resolution(root, site, target, source))
46
+ .is_some_and(|resolution| resolution.matches(&[BUILD_CONTEXT]))
49
47
  }
50
48
 
51
49
  pub(super) fn navigation_receiver_accepts_route_location(
@@ -58,9 +56,8 @@ pub(super) fn navigation_receiver_accepts_route_location(
58
56
  if go_router_receiver_expression(root, site, receiver, source) {
59
57
  return true;
60
58
  }
61
- navigation_target_name(receiver).is_some_and(|target| {
62
- target_resolves_to_navigation_type(root, site, &target, &[BUILD_CONTEXT, GO_ROUTER], source)
63
- })
59
+ navigation_expression_resolution(root, site, receiver, source)
60
+ .is_some_and(|resolution| resolution.matches(&[BUILD_CONTEXT, GO_ROUTER]))
64
61
  }
65
62
 
66
63
  fn go_router_receiver_expression(
@@ -325,19 +322,76 @@ fn navigation_target_name(text: &str) -> Option<NavigationTargetName> {
325
322
  })
326
323
  }
327
324
 
328
- fn target_resolves_to_navigation_type(
325
+ fn navigation_expression_resolution(
329
326
  root: Node<'_>,
330
327
  site: Node<'_>,
331
- target: &NavigationTargetName,
332
- accepted: &[&str],
328
+ expression: &str,
329
+ source: &str,
330
+ ) -> Option<NameResolution> {
331
+ let compact = strip_whitespace(expression.trim());
332
+ let unwrapped = unwrap_parenthesized_text(&compact).unwrap_or(&compact);
333
+ let expression = unwrapped.trim_end_matches(['?', '!']);
334
+ if navigator_context_expression(root, site, expression, source) {
335
+ return Some(NameResolution::Type(BUILD_CONTEXT.to_owned()));
336
+ }
337
+ if let Some(target) = navigation_target_name(expression) {
338
+ return if target.member_only {
339
+ class_member_resolution_at(root, site, &target.name, source)
340
+ } else {
341
+ visible_name_resolution_at(root, site, &target.name, source)
342
+ };
343
+ }
344
+ let (receiver, member) = expression.rsplit_once('.')?;
345
+ if !is_simple_identifier(receiver) || !is_simple_identifier(member) {
346
+ return None;
347
+ }
348
+ let NameResolution::Type(owner_type) =
349
+ visible_name_resolution_at(root, site, receiver, source)?
350
+ else {
351
+ return Some(NameResolution::Shadowed);
352
+ };
353
+ local_type_member_resolution(root, &owner_type, member, source)
354
+ }
355
+
356
+ fn navigator_context_expression(
357
+ root: Node<'_>,
358
+ site: Node<'_>,
359
+ expression: &str,
333
360
  source: &str,
334
361
  ) -> bool {
335
- let resolution = if target.member_only {
336
- class_member_resolution_at(root, site, &target.name, source)
337
- } else {
338
- visible_name_resolution_at(root, site, &target.name, source)
362
+ let Some(factory) = expression.strip_suffix(".context") else {
363
+ return false;
339
364
  };
340
- resolution.is_some_and(|resolution| resolution.matches(accepted))
365
+ if !direct_static_member_call_text(factory, "Navigator", "of")
366
+ || term_identifier_shadowed_at(root, site, "Navigator", source)
367
+ || !framework_build_context_import(root, None, source)
368
+ {
369
+ return false;
370
+ }
371
+ let mut context_argument_resolves = false;
372
+ visit_named(site, &mut |node| {
373
+ if context_argument_resolves
374
+ || !matches!(
375
+ node.kind(),
376
+ "call_expression" | "function_expression_invocation"
377
+ )
378
+ {
379
+ return;
380
+ }
381
+ let Some(arguments) = argument_list(node) else {
382
+ return;
383
+ };
384
+ let Some(prefix) = source.get(node.start_byte()..arguments.start_byte()) else {
385
+ return;
386
+ };
387
+ if strip_whitespace(prefix) == "Navigator.of" {
388
+ context_argument_resolves = first_positional_argument(arguments)
389
+ .and_then(|argument| argument.utf8_text(source.as_bytes()).ok())
390
+ .and_then(|argument| navigation_expression_resolution(root, node, argument, source))
391
+ .is_some_and(|resolution| resolution.matches(&[BUILD_CONTEXT]));
392
+ }
393
+ });
394
+ context_argument_resolves
341
395
  }
342
396
 
343
397
  fn visible_name_resolution_at(
@@ -505,6 +559,9 @@ fn declaration_type_resolution(
505
559
  return formal_parameter_type(root, node, name, source)
506
560
  .map_or(NameResolution::Shadowed, NameResolution::Type);
507
561
  }
562
+ if let Some(resolution) = object_pattern_member_resolution(root, node, name, source) {
563
+ return resolution;
564
+ }
508
565
  if let Some(resolution) = declared_type_for_name(root, node, name, source) {
509
566
  return resolution;
510
567
  }
@@ -611,9 +668,8 @@ fn initializer_type_for_name(
611
668
  }
612
669
 
613
670
  fn initializer_type(root: Node<'_>, node: Node<'_>, source: &str) -> Option<String> {
614
- let text = node.utf8_text(source.as_bytes()).ok()?;
615
- let (_, right) = text.split_once('=')?;
616
- let expression = right.trim().trim_end_matches([',', ';']).trim();
671
+ let value = node.child_by_field_name("value")?;
672
+ let expression = value.utf8_text(source.as_bytes()).ok()?.trim();
617
673
  let unwrapped = unwrap_parenthesized_text(expression).unwrap_or(expression);
618
674
  let without_postfix = unwrapped.trim_end_matches(['?', '!']).trim();
619
675
  let unwrapped = unwrap_parenthesized_text(without_postfix).unwrap_or(without_postfix);
@@ -627,7 +683,60 @@ fn initializer_type(root: Node<'_>, node: Node<'_>, source: &str) -> Option<Stri
627
683
  return Some(target_type.to_owned());
628
684
  }
629
685
  }
630
- None
686
+ match navigation_expression_resolution(root, node, expression, source)? {
687
+ NameResolution::Type(type_name) => Some(type_name),
688
+ NameResolution::Shadowed => None,
689
+ }
690
+ }
691
+
692
+ fn object_pattern_member_resolution(
693
+ root: Node<'_>,
694
+ node: Node<'_>,
695
+ name: &str,
696
+ source: &str,
697
+ ) -> Option<NameResolution> {
698
+ let mut owner_type = None;
699
+ visit_named(node, &mut |candidate| {
700
+ if owner_type.is_some()
701
+ || candidate.kind() != "object_pattern"
702
+ || !declaration_binds_name(candidate, name, source)
703
+ {
704
+ return;
705
+ }
706
+ let Some(text) = candidate.utf8_text(source.as_bytes()).ok() else {
707
+ return;
708
+ };
709
+ let Some((raw_type, _)) = text.split_once('(') else {
710
+ return;
711
+ };
712
+ let type_name = simple_type_name(raw_type.trim());
713
+ if is_simple_identifier(&type_name) {
714
+ owner_type = Some(type_name);
715
+ }
716
+ });
717
+ local_type_member_resolution(root, &owner_type?, name, source)
718
+ }
719
+
720
+ fn local_type_member_resolution(
721
+ root: Node<'_>,
722
+ owner_type: &str,
723
+ member_name: &str,
724
+ source: &str,
725
+ ) -> Option<NameResolution> {
726
+ let mut resolution = None;
727
+ visit_named(root, &mut |candidate| {
728
+ if resolution.is_some()
729
+ || candidate.kind() != "class_declaration"
730
+ || field_text(candidate, "name", source).as_deref() != Some(owner_type)
731
+ {
732
+ return;
733
+ }
734
+ let Some(body) = candidate.child_by_field_name("body") else {
735
+ return;
736
+ };
737
+ resolution = class_member_resolution(root, body, member_name, source);
738
+ });
739
+ resolution
631
740
  }
632
741
 
633
742
  fn scoped_header_binding_exists(
@@ -756,7 +865,9 @@ fn is_body_statement_child(kind: &str) -> bool {
756
865
  }
757
866
 
758
867
  fn declaration_binds_name(node: Node<'_>, name: &str, source: &str) -> bool {
759
- if binding_name(node, source).as_deref() == Some(name) {
868
+ if binding_name(node, source).as_deref() == Some(name)
869
+ || object_pattern_shorthand_binds_name(node, name, source)
870
+ {
760
871
  return true;
761
872
  }
762
873
  if is_callable_node(node.kind()) {
@@ -767,6 +878,23 @@ fn declaration_binds_name(node: Node<'_>, name: &str, source: &str) -> bool {
767
878
  .any(|child| declaration_binds_name(child, name, source))
768
879
  }
769
880
 
881
+ fn object_pattern_shorthand_binds_name(node: Node<'_>, name: &str, source: &str) -> bool {
882
+ if node.kind() != "object_pattern" {
883
+ return false;
884
+ }
885
+ let Some(text) = node.utf8_text(source.as_bytes()).ok() else {
886
+ return false;
887
+ };
888
+ let compact = strip_whitespace(text);
889
+ let marker = format!(":{name}");
890
+ compact.match_indices(&marker).any(|(start, _)| {
891
+ compact
892
+ .get(start + marker.len()..)
893
+ .and_then(|rest| rest.chars().next())
894
+ .is_none_or(|character| !is_identifier_character(character))
895
+ })
896
+ }
897
+
770
898
  fn binding_name(node: Node<'_>, source: &str) -> Option<String> {
771
899
  if !matches!(
772
900
  node.kind(),
@@ -181,7 +181,10 @@ fn raw_receiver_before_navigation<'source>(
181
181
  }
182
182
 
183
183
  fn constructor_receiver_text(receiver: &str) -> String {
184
- let trimmed = receiver.trim();
184
+ let trimmed = receiver
185
+ .rsplit_once("=>")
186
+ .map_or(receiver, |(_, expression)| expression)
187
+ .trim();
185
188
  let unwrapped = unwrap_parenthesized_text(trimmed).unwrap_or(trimmed);
186
189
  let without_keyword = strip_constructor_keyword_prefix(unwrapped).unwrap_or(unwrapped);
187
190
  strip_whitespace(without_keyword)