dart-decimate 0.0.75 → 0.0.76

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 (45) hide show
  1. package/Cargo.lock +1 -1
  2. package/Cargo.toml +1 -1
  3. package/README.md +11 -10
  4. package/package.json +2 -2
  5. package/src/baseline.rs +5 -16
  6. package/src/cli/issue_filter_args.rs +10 -0
  7. package/src/config/rule_aliases.rs +6 -0
  8. package/src/config/rules.rs +3 -6
  9. package/src/dependencies/analyze.rs +14 -3
  10. package/src/dependencies/overrides.rs +9 -1
  11. package/src/dependencies/package_cycles.rs +69 -0
  12. package/src/dependencies/package_graph.rs +53 -0
  13. package/src/dependencies/usage.rs +9 -0
  14. package/src/dependencies.rs +63 -8
  15. package/src/explain.rs +21 -9
  16. package/src/extract/members.rs +159 -6
  17. package/src/extract/tests.rs +35 -0
  18. package/src/extract.rs +48 -51
  19. package/src/generated.rs +10 -1
  20. package/src/graph/augment_tests.rs +1 -0
  21. package/src/graph/package_config_tests.rs +3 -0
  22. package/src/graph/pubspec_tests.rs +1 -0
  23. package/src/graph/tests.rs +3 -0
  24. package/src/graph/uri_tests.rs +1 -0
  25. package/src/health/coverage.rs +1 -1
  26. package/src/health/tests.rs +54 -0
  27. package/src/health/thresholds.rs +1 -1
  28. package/src/health/types.rs +2 -2
  29. package/src/intelligence/tests.rs +2 -0
  30. package/src/lib.rs +5 -10
  31. package/src/manifest.rs +3 -2
  32. package/src/mcp/cli_args/value_args.rs +1 -0
  33. package/src/output/dependency_findings.rs +41 -2
  34. package/src/output/human_details.rs +8 -0
  35. package/src/output/suppressions.rs +1 -0
  36. package/src/output/symbol_findings.rs +6 -2
  37. package/src/output/types.rs +10 -6
  38. package/src/output.rs +2 -0
  39. package/src/report_schema.rs +2 -0
  40. package/src/security_gate.rs +3 -6
  41. package/src/symbols/duplicate_declarations.rs +237 -0
  42. package/src/symbols/tests.rs +1 -0
  43. package/src/symbols.rs +354 -10
  44. package/src/widgets/resolution.rs +6 -6
  45. package/src/widgets.rs +1 -4
@@ -0,0 +1,237 @@
1
+ use std::collections::{BTreeMap, BTreeSet};
2
+ use std::path::{Path, PathBuf};
3
+
4
+ use crate::generated::is_generated_dart_path;
5
+ use crate::{DartCombinator, DeadCodeReport, DependencyKind, ScannedProject};
6
+
7
+ use super::path_filters::{is_library_source, is_private};
8
+ use super::{DuplicateExport, DuplicateExportDeclaration, SymbolIndex, is_visible_through_export};
9
+
10
+ type Exposure = BTreeMap<String, BTreeSet<PathBuf>>;
11
+
12
+ struct Directive {
13
+ exports: bool,
14
+ prefix: Option<String>,
15
+ targets: BTreeSet<PathBuf>,
16
+ combinators: Vec<DartCombinator>,
17
+ }
18
+
19
+ struct LibraryGraph {
20
+ declared: BTreeMap<PathBuf, BTreeMap<String, DuplicateExportDeclaration>>,
21
+ directives: BTreeMap<PathBuf, Vec<Directive>>,
22
+ }
23
+
24
+ pub(super) fn duplicate_declarations_across_libraries(
25
+ project: &ScannedProject,
26
+ dead_code: &DeadCodeReport,
27
+ index: &SymbolIndex,
28
+ already_reported: &[DuplicateExport],
29
+ ) -> Vec<DuplicateExport> {
30
+ let reachable = dead_code
31
+ .reachable_files
32
+ .iter()
33
+ .collect::<BTreeSet<&PathBuf>>();
34
+ let dead = dead_code
35
+ .dead_files
36
+ .iter()
37
+ .map(|dead_file| &dead_file.path)
38
+ .collect::<BTreeSet<&PathBuf>>();
39
+ let reported = already_reported
40
+ .iter()
41
+ .map(|duplicate| {
42
+ (
43
+ duplicate.name.as_str(),
44
+ duplicate
45
+ .declarations
46
+ .iter()
47
+ .map(|declaration| &declaration.path)
48
+ .collect::<BTreeSet<_>>(),
49
+ )
50
+ })
51
+ .collect::<BTreeSet<_>>();
52
+ let graph = LibraryGraph {
53
+ declared: declared_names(project, &reachable, &dead, index),
54
+ directives: directives_by_library(project, index),
55
+ };
56
+
57
+ let mut memo = BTreeMap::new();
58
+ let mut seen = BTreeMap::<(String, BTreeSet<PathBuf>), PathBuf>::new();
59
+ for (library, directives) in &graph.directives {
60
+ if dead.contains(library) || is_generated_dart_path(library) {
61
+ continue;
62
+ }
63
+ let mut namespaces =
64
+ BTreeMap::<(bool, Option<&str>), BTreeMap<String, Vec<BTreeSet<PathBuf>>>>::new();
65
+ for directive in directives {
66
+ let names = namespaces
67
+ .entry((directive.exports, directive.prefix.as_deref()))
68
+ .or_default();
69
+ for (name, libraries) in directive_supply(directive, &graph, &mut memo) {
70
+ names.entry(name).or_default().push(libraries);
71
+ }
72
+ }
73
+ for (name, suppliers) in namespaces.into_values().flatten() {
74
+ let declaring = suppliers.iter().flatten().cloned().collect::<BTreeSet<_>>();
75
+ if suppliers.len() > 1 && declaring.len() > 1 {
76
+ seen.entry((name, declaring))
77
+ .or_insert_with(|| library.clone());
78
+ }
79
+ }
80
+ }
81
+
82
+ seen.into_iter()
83
+ .filter_map(|((name, libraries), entry_path)| {
84
+ let mut declarations = libraries
85
+ .iter()
86
+ .filter_map(|library| graph.declared.get(library)?.get(&name))
87
+ .cloned()
88
+ .collect::<Vec<_>>();
89
+ declarations.sort_by(|left, right| left.path.cmp(&right.path));
90
+ let already_reported = {
91
+ let paths = declarations
92
+ .iter()
93
+ .map(|declaration| &declaration.path)
94
+ .collect::<BTreeSet<_>>();
95
+ reported.contains(&(name.as_str(), paths))
96
+ };
97
+ (declarations.len() > 1 && !already_reported).then_some(DuplicateExport {
98
+ entry_path,
99
+ name,
100
+ declarations,
101
+ safe_to_delete: false,
102
+ })
103
+ })
104
+ .collect()
105
+ }
106
+
107
+ fn declared_names(
108
+ project: &ScannedProject,
109
+ reachable: &BTreeSet<&PathBuf>,
110
+ dead: &BTreeSet<&PathBuf>,
111
+ index: &SymbolIndex,
112
+ ) -> BTreeMap<PathBuf, BTreeMap<String, DuplicateExportDeclaration>> {
113
+ let mut declared = BTreeMap::<PathBuf, BTreeMap<String, DuplicateExportDeclaration>>::new();
114
+ for indexed in &index.declarations {
115
+ let name = indexed.declaration.name.as_str();
116
+ if name.is_empty()
117
+ || name == "main"
118
+ || is_private(name)
119
+ || !reachable.contains(&indexed.path)
120
+ || dead.contains(&indexed.path)
121
+ || is_generated_dart_path(&indexed.path)
122
+ || !is_library_source(&project.root, &indexed.path)
123
+ {
124
+ continue;
125
+ }
126
+ declared
127
+ .entry(index.library_path(&indexed.path).to_path_buf())
128
+ .or_default()
129
+ .entry(name.to_owned())
130
+ .or_insert_with(|| DuplicateExportDeclaration {
131
+ path: indexed.path.clone(),
132
+ kind: indexed.declaration.kind,
133
+ location: indexed.declaration.location,
134
+ });
135
+ }
136
+ declared
137
+ }
138
+
139
+ fn directives_by_library(
140
+ project: &ScannedProject,
141
+ index: &SymbolIndex,
142
+ ) -> BTreeMap<PathBuf, Vec<Directive>> {
143
+ let mut grouped = BTreeMap::<(PathBuf, u8, usize, usize), Directive>::new();
144
+ for edge in project.graph.dependencies() {
145
+ if !matches!(edge.kind, DependencyKind::Import | DependencyKind::Export) {
146
+ continue;
147
+ }
148
+ grouped
149
+ .entry((
150
+ edge.from_path.clone(),
151
+ edge.kind as u8,
152
+ edge.location.line,
153
+ edge.location.column,
154
+ ))
155
+ .or_insert_with(|| Directive {
156
+ exports: edge.kind == DependencyKind::Export,
157
+ prefix: edge.visibility.prefix.clone(),
158
+ targets: BTreeSet::new(),
159
+ combinators: edge.visibility.combinators.clone(),
160
+ })
161
+ .targets
162
+ .insert(index.library_path(&edge.to_path).to_path_buf());
163
+ }
164
+ let mut by_library = BTreeMap::<PathBuf, Vec<Directive>>::new();
165
+ for ((from_path, ..), directive) in grouped {
166
+ by_library
167
+ .entry(index.library_path(&from_path).to_path_buf())
168
+ .or_default()
169
+ .push(directive);
170
+ }
171
+ by_library
172
+ }
173
+
174
+ fn directive_supply(
175
+ directive: &Directive,
176
+ graph: &LibraryGraph,
177
+ memo: &mut BTreeMap<PathBuf, Exposure>,
178
+ ) -> Exposure {
179
+ directive_supply_guarded(directive, graph, memo, &mut BTreeSet::new())
180
+ }
181
+
182
+ fn directive_supply_guarded(
183
+ directive: &Directive,
184
+ graph: &LibraryGraph,
185
+ memo: &mut BTreeMap<PathBuf, Exposure>,
186
+ active: &mut BTreeSet<PathBuf>,
187
+ ) -> Exposure {
188
+ let mut supply = Exposure::new();
189
+ for target in &directive.targets {
190
+ for (name, libraries) in exposure(target, graph, memo, active) {
191
+ if is_visible_through_export(&name, &directive.combinators) {
192
+ supply.entry(name).or_default().extend(libraries);
193
+ }
194
+ }
195
+ }
196
+ supply
197
+ }
198
+
199
+ fn exposure(
200
+ library: &Path,
201
+ graph: &LibraryGraph,
202
+ memo: &mut BTreeMap<PathBuf, Exposure>,
203
+ active: &mut BTreeSet<PathBuf>,
204
+ ) -> Exposure {
205
+ if let Some(done) = memo.get(library) {
206
+ return done.clone();
207
+ }
208
+ if !active.insert(library.to_path_buf()) {
209
+ return Exposure::new();
210
+ }
211
+ let mut result = Exposure::new();
212
+ for name in graph
213
+ .declared
214
+ .get(library)
215
+ .into_iter()
216
+ .flat_map(BTreeMap::keys)
217
+ {
218
+ result
219
+ .entry(name.clone())
220
+ .or_default()
221
+ .insert(library.to_path_buf());
222
+ }
223
+ for directive in graph
224
+ .directives
225
+ .get(library)
226
+ .into_iter()
227
+ .flatten()
228
+ .filter(|directive| directive.exports)
229
+ {
230
+ for (name, libraries) in directive_supply_guarded(directive, graph, memo, active) {
231
+ result.entry(name).or_default().extend(libraries);
232
+ }
233
+ }
234
+ active.remove(library);
235
+ memo.insert(library.to_path_buf(), result.clone());
236
+ result
237
+ }
@@ -243,6 +243,7 @@ void runLive() {
243
243
  ("Mode", "off", MemberKind::EnumConstant),
244
244
  ("Controller", "_unusedField", MemberKind::Field),
245
245
  ("Controller", "_unused", MemberKind::Method),
246
+ ("Controller", "publicUnused", MemberKind::Method),
246
247
  ("InternalText", "_unusedLength", MemberKind::Getter),
247
248
  ]
248
249
  );
package/src/symbols.rs CHANGED
@@ -3,19 +3,23 @@ use std::path::{Path, PathBuf};
3
3
 
4
4
  use serde::{Deserialize, Serialize};
5
5
 
6
+ use crate::dependencies::{PackageScope, package_scopes};
6
7
  use crate::generated::is_generated_dart_path;
7
8
  use crate::graph::normalize_against;
9
+ use crate::widgets::resolution::{ClassKey, DeclarationResolver};
8
10
  use crate::{
9
11
  DartCombinatorKind, DeadCodeReport, DeclarationKind, DependencyKind, Location,
10
12
  MemberDeclaration, MemberKind, ScannedProject, TopLevelDeclaration,
11
13
  };
12
14
 
15
+ mod duplicate_declarations;
13
16
  mod extensions;
14
17
  mod index;
15
18
  mod path_filters;
16
19
  mod private_type_leaks;
17
20
  mod riverpod;
18
21
  mod semantic_evidence;
22
+ use duplicate_declarations::duplicate_declarations_across_libraries;
19
23
  use extensions::extend_implicit_extension_references;
20
24
  use path_filters::{is_library_source, is_private, is_public_library_entry};
21
25
  pub use private_type_leaks::PrivateTypeLeak;
@@ -135,7 +139,15 @@ pub fn analyze_symbols_with_options(
135
139
  options: SymbolAnalysisOptions,
136
140
  ) -> SymbolReport {
137
141
  let index = SymbolIndex::from_project(project);
138
- let duplicate_exports = duplicate_exports_from_public(&index.public_exported_declarations);
142
+ let mut duplicate_exports = duplicate_exports_from_public(&index.public_exported_declarations);
143
+ if let Some(dead_code) = dead_code {
144
+ let across_libraries =
145
+ duplicate_declarations_across_libraries(project, dead_code, &index, &duplicate_exports);
146
+ duplicate_exports.extend(across_libraries);
147
+ duplicate_exports.sort_by(|left, right| {
148
+ (&left.entry_path, &left.name).cmp(&(&right.entry_path, &right.name))
149
+ });
150
+ }
139
151
  let private_type_leaks = if options.private_type_leaks {
140
152
  private_type_leaks(project, &index)
141
153
  } else {
@@ -247,11 +259,18 @@ fn unused_members(
247
259
  .map(|dead_file| dead_file.path.clone())
248
260
  .collect::<BTreeSet<_>>();
249
261
 
262
+ let public_members = PublicMemberContext::new(project, dead_code, index);
250
263
  let mut unused_members = index
251
264
  .members
252
265
  .iter()
253
266
  .filter_map(|member| {
254
- unused_member_from_declaration(project, index, &reachable_files, &dead_files, member)
267
+ unused_member_from_declaration(
268
+ project,
269
+ index,
270
+ (&reachable_files, &dead_files),
271
+ &public_members,
272
+ member,
273
+ )
255
274
  })
256
275
  .collect::<Vec<_>>();
257
276
 
@@ -339,16 +358,16 @@ fn is_simple_unused_declaration(index: &SymbolIndex, indexed: &IndexedDeclaratio
339
358
  fn unused_member_from_declaration(
340
359
  project: &ScannedProject,
341
360
  index: &SymbolIndex,
342
- reachable_files: &BTreeSet<PathBuf>,
343
- dead_files: &BTreeSet<PathBuf>,
361
+ (reachable_files, dead_files): (&BTreeSet<PathBuf>, &BTreeSet<PathBuf>),
362
+ public_members: &PublicMemberContext,
344
363
  indexed: &IndexedMember,
345
364
  ) -> Option<UnusedMember> {
346
365
  if !indexed.path.starts_with(&project.root)
347
366
  || !reachable_files.contains(&indexed.path)
348
367
  || dead_files.contains(&indexed.path)
349
368
  || is_generated_dart_path(&indexed.path)
350
- || !is_library_source(&project.root, &indexed.path)
351
- || !should_check_member(index, indexed)
369
+ || !public_members.in_library(&project.root, &indexed.path)
370
+ || !should_check_member(index, public_members, indexed)
352
371
  {
353
372
  return None;
354
373
  }
@@ -360,9 +379,11 @@ fn unused_member_from_declaration(
360
379
  reachable_files,
361
380
  ) + index.dot_shorthand_reference_count(&indexed.member.name, reachable_files)
362
381
  + index.qualified_reference_count(&indexed.member.owner, "values", reachable_files)
363
- } else {
382
+ } else if is_private(&indexed.member.name) {
364
383
  let library = index.library_path(&indexed.path);
365
384
  index.library_reference_count(&indexed.member.name, library, reachable_files)
385
+ } else {
386
+ index.reference_count(&indexed.member.name, reachable_files)
366
387
  };
367
388
  if reference_count != 0 {
368
389
  return None;
@@ -379,19 +400,335 @@ fn unused_member_from_declaration(
379
400
  })
380
401
  }
381
402
 
382
- fn should_check_member(index: &SymbolIndex, indexed: &IndexedMember) -> bool {
403
+ fn should_check_member(
404
+ index: &SymbolIndex,
405
+ public_members: &PublicMemberContext,
406
+ indexed: &IndexedMember,
407
+ ) -> bool {
383
408
  match indexed.member.kind {
384
409
  MemberKind::EnumConstant => {
385
410
  !is_private(&indexed.member.name)
386
411
  && !index.is_public_export(&indexed.path, &indexed.member.owner)
412
+ && !public_members.exports_class(&indexed.path, &indexed.member.owner)
387
413
  }
388
414
  MemberKind::Field | MemberKind::Getter | MemberKind::Setter | MemberKind::Method => {
389
- is_private(&indexed.member.name)
415
+ is_private(&indexed.member.name) || public_members.checks(index, indexed)
390
416
  }
391
417
  MemberKind::Constructor | MemberKind::Operator => false,
392
418
  }
393
419
  }
394
420
 
421
+ const CONTRACT_MEMBER_NAMES: &[&str] = &[
422
+ "build",
423
+ "call",
424
+ "createState",
425
+ "fromJson",
426
+ "hashCode",
427
+ "noSuchMethod",
428
+ "toJson",
429
+ "toString",
430
+ ];
431
+
432
+ struct PublicMemberContext {
433
+ class_owners: BTreeSet<(PathBuf, String)>,
434
+ generated_part_libraries: BTreeSet<PathBuf>,
435
+ entry_points: BTreeSet<PathBuf>,
436
+ packages: Vec<PackageScope>,
437
+ public_classes: BTreeSet<(PathBuf, String)>,
438
+ interface_skips: InterfaceSkips,
439
+ }
440
+
441
+ struct HierarchyClass {
442
+ extended: BTreeSet<ClassKey>,
443
+ mixed: BTreeSet<ClassKey>,
444
+ implemented: BTreeSet<ClassKey>,
445
+ outside_extended: bool,
446
+ outside_interface: bool,
447
+ }
448
+
449
+ #[derive(Default)]
450
+ struct DeclaredNames {
451
+ all: BTreeSet<String>,
452
+ without_body: BTreeSet<String>,
453
+ }
454
+
455
+ #[derive(Default)]
456
+ struct InterfaceSkips {
457
+ whole_classes: BTreeSet<ClassKey>,
458
+ named_members: BTreeMap<ClassKey, BTreeSet<String>>,
459
+ }
460
+
461
+ impl InterfaceSkips {
462
+ fn protects(&self, class: &ClassKey, member: &str) -> bool {
463
+ self.whole_classes.contains(class)
464
+ || self
465
+ .named_members
466
+ .get(class)
467
+ .is_some_and(|names| names.contains(member))
468
+ }
469
+ }
470
+
471
+ type Hierarchy = (
472
+ BTreeMap<ClassKey, HierarchyClass>,
473
+ BTreeMap<ClassKey, DeclaredNames>,
474
+ );
475
+
476
+ fn class_hierarchy(project: &ScannedProject, index: &SymbolIndex) -> Hierarchy {
477
+ let resolver = DeclarationResolver::new(
478
+ project,
479
+ index.declarations.iter().map(|indexed| ClassKey {
480
+ path: indexed.path.clone(),
481
+ name: indexed.declaration.name.clone(),
482
+ }),
483
+ );
484
+ let mut classes = BTreeMap::<ClassKey, HierarchyClass>::new();
485
+ let mut member_names = BTreeMap::<ClassKey, DeclaredNames>::new();
486
+ for file in &project.files {
487
+ let path = normalize_against(&project.root, &file.path);
488
+ for member in &file.members {
489
+ let declared = member_names
490
+ .entry(ClassKey {
491
+ path: path.clone(),
492
+ name: member.owner.clone(),
493
+ })
494
+ .or_default();
495
+ declared.all.insert(member.name.clone());
496
+ if !member.has_body {
497
+ declared.without_body.insert(member.name.clone());
498
+ }
499
+ }
500
+ for class in &file.class_supertypes {
501
+ let resolve_all = |names: &[String]| {
502
+ let sets = names
503
+ .iter()
504
+ .map(|name| resolver.resolve(&path, name))
505
+ .collect::<Vec<_>>();
506
+ let outside = sets.iter().any(BTreeSet::is_empty);
507
+ (sets.into_iter().flatten().collect::<BTreeSet<_>>(), outside)
508
+ };
509
+ let superclasses = class
510
+ .names
511
+ .iter()
512
+ .filter(|name| !matches!(name.as_str(), "Object" | "core.Object"))
513
+ .cloned()
514
+ .collect::<Vec<_>>();
515
+ let (extended, outside_extended) = resolve_all(&superclasses);
516
+ let (mixed, outside_mixed) = resolve_all(&class.mixins);
517
+ let (implemented, outside_implemented) = resolve_all(&class.implemented);
518
+ let key = ClassKey {
519
+ path: path.clone(),
520
+ name: class.owner.clone(),
521
+ };
522
+ classes.insert(
523
+ key,
524
+ HierarchyClass {
525
+ extended,
526
+ mixed,
527
+ implemented,
528
+ outside_extended,
529
+ outside_interface: outside_mixed || outside_implemented,
530
+ },
531
+ );
532
+ }
533
+ }
534
+ (classes, member_names)
535
+ }
536
+
537
+ fn reached_interfaces(
538
+ class: &HierarchyClass,
539
+ classes: &BTreeMap<ClassKey, HierarchyClass>,
540
+ ) -> (BTreeMap<ClassKey, bool>, bool) {
541
+ let mut reached = BTreeMap::<ClassKey, bool>::new();
542
+ let mut open = class.outside_interface;
543
+ let mut pending = class
544
+ .mixed
545
+ .iter()
546
+ .map(|mixin| (mixin.clone(), false))
547
+ .chain(
548
+ class
549
+ .implemented
550
+ .iter()
551
+ .map(|interface| (interface.clone(), true)),
552
+ )
553
+ .collect::<Vec<_>>();
554
+ if !class.mixed.is_empty() {
555
+ open |= class.outside_extended;
556
+ pending.extend(class.extended.iter().map(|parent| (parent.clone(), false)));
557
+ }
558
+ while let Some((reached_class, duty)) = pending.pop() {
559
+ if reached
560
+ .get(&reached_class)
561
+ .is_some_and(|known| *known || !duty)
562
+ {
563
+ continue;
564
+ }
565
+ reached.insert(reached_class.clone(), duty);
566
+ if let Some(parent) = classes.get(&reached_class) {
567
+ open |= parent.outside_extended || parent.outside_interface;
568
+ pending.extend(
569
+ parent
570
+ .extended
571
+ .iter()
572
+ .chain(&parent.mixed)
573
+ .map(|supertype| (supertype.clone(), duty))
574
+ .chain(
575
+ parent
576
+ .implemented
577
+ .iter()
578
+ .map(|interface| (interface.clone(), true)),
579
+ ),
580
+ );
581
+ }
582
+ }
583
+ (reached, open)
584
+ }
585
+
586
+ fn interface_skips(project: &ScannedProject, index: &SymbolIndex) -> InterfaceSkips {
587
+ let (classes, member_names) = class_hierarchy(project, index);
588
+ let mut skips = InterfaceSkips::default();
589
+ for class in classes.values() {
590
+ let (reached, open) = reached_interfaces(class, &classes);
591
+ if reached.is_empty() && !open {
592
+ continue;
593
+ }
594
+ let mut ancestors = BTreeSet::new();
595
+ let mut pending = class
596
+ .extended
597
+ .iter()
598
+ .chain(&class.mixed)
599
+ .cloned()
600
+ .collect::<Vec<_>>();
601
+ while let Some(ancestor) = pending.pop() {
602
+ if ancestors.insert(ancestor.clone())
603
+ && let Some(parent) = classes.get(&ancestor)
604
+ {
605
+ pending.extend(parent.extended.iter().chain(&parent.mixed).cloned());
606
+ }
607
+ }
608
+ if open {
609
+ skips.whole_classes.extend(ancestors);
610
+ continue;
611
+ }
612
+ for ancestor in &ancestors {
613
+ let ancestor_is_reached = reached.contains_key(ancestor);
614
+ let names = reached
615
+ .iter()
616
+ .filter(|(reached_class, _)| *reached_class != ancestor)
617
+ .filter_map(|(reached_class, duty)| {
618
+ member_names.get(reached_class).map(|declared| {
619
+ if *duty || !ancestor_is_reached {
620
+ &declared.all
621
+ } else {
622
+ &declared.without_body
623
+ }
624
+ })
625
+ })
626
+ .flatten()
627
+ .cloned()
628
+ .collect::<BTreeSet<_>>();
629
+ skips
630
+ .named_members
631
+ .entry(ancestor.clone())
632
+ .or_default()
633
+ .extend(names);
634
+ }
635
+ }
636
+ skips
637
+ }
638
+
639
+ fn owning_scope<'scope>(
640
+ packages: &'scope [PackageScope],
641
+ path: &Path,
642
+ ) -> Option<&'scope PackageScope> {
643
+ packages
644
+ .iter()
645
+ .filter(|scope| path.starts_with(&scope.root))
646
+ .max_by_key(|scope| scope.root.components().count())
647
+ }
648
+
649
+ impl PublicMemberContext {
650
+ fn new(project: &ScannedProject, dead_code: &DeadCodeReport, index: &SymbolIndex) -> Self {
651
+ let packages = package_scopes(&project.root);
652
+ let public_classes = public_exported_declarations_from(project, |path| {
653
+ owning_scope(&packages, path).map_or_else(
654
+ || is_public_library_entry(&project.root, path),
655
+ |scope| !scope.application && is_public_library_entry(&scope.root, path),
656
+ )
657
+ })
658
+ .into_iter()
659
+ .map(|exported| (exported.path, exported.declaration.name))
660
+ .collect();
661
+ Self {
662
+ interface_skips: interface_skips(project, index),
663
+ packages,
664
+ public_classes,
665
+ class_owners: index
666
+ .declarations
667
+ .iter()
668
+ .filter(|indexed| {
669
+ matches!(
670
+ indexed.declaration.kind,
671
+ DeclarationKind::Class | DeclarationKind::Mixin
672
+ )
673
+ })
674
+ .map(|indexed| (indexed.path.clone(), indexed.declaration.name.clone()))
675
+ .collect(),
676
+ generated_part_libraries: project
677
+ .files
678
+ .iter()
679
+ .filter(|file| {
680
+ file.parts
681
+ .iter()
682
+ .any(|part| is_generated_dart_path(Path::new(&part.uri)))
683
+ })
684
+ .map(|file| {
685
+ index
686
+ .library_path(&normalize_against(&project.root, &file.path))
687
+ .to_path_buf()
688
+ })
689
+ .collect(),
690
+ entry_points: dead_code.entry_points.iter().cloned().collect(),
691
+ }
692
+ }
693
+
694
+ fn exports_class(&self, path: &Path, owner: &str) -> bool {
695
+ self.public_classes
696
+ .contains(&(path.to_path_buf(), owner.to_owned()))
697
+ }
698
+
699
+ fn in_library(&self, root: &Path, path: &Path) -> bool {
700
+ owning_scope(&self.packages, path).map_or_else(
701
+ || is_library_source(root, path),
702
+ |scope| is_library_source(&scope.root, path),
703
+ )
704
+ }
705
+
706
+ fn is_runtime_entry(&self, path: &Path) -> bool {
707
+ self.entry_points.contains(path)
708
+ && owning_scope(&self.packages, path).is_none_or(|scope| !scope.application)
709
+ }
710
+
711
+ fn checks(&self, index: &SymbolIndex, indexed: &IndexedMember) -> bool {
712
+ !indexed.member.contract
713
+ && !CONTRACT_MEMBER_NAMES.contains(&indexed.member.name.as_str())
714
+ && self
715
+ .class_owners
716
+ .contains(&(indexed.path.clone(), indexed.member.owner.clone()))
717
+ && !self.interface_skips.protects(
718
+ &ClassKey {
719
+ path: indexed.path.clone(),
720
+ name: indexed.member.owner.clone(),
721
+ },
722
+ &indexed.member.name,
723
+ )
724
+ && !self.is_runtime_entry(&indexed.path)
725
+ && !self.exports_class(&indexed.path, &indexed.member.owner)
726
+ && !self
727
+ .generated_part_libraries
728
+ .contains(index.library_path(&indexed.path))
729
+ }
730
+ }
731
+
395
732
  fn library_by_path(project: &ScannedProject) -> BTreeMap<PathBuf, PathBuf> {
396
733
  let dependencies = project.graph.dependencies();
397
734
  let part_edges = dependencies
@@ -418,12 +755,19 @@ fn library_by_path(project: &ScannedProject) -> BTreeMap<PathBuf, PathBuf> {
418
755
  }
419
756
 
420
757
  fn public_exported_declarations(project: &ScannedProject) -> Vec<PublicExportedDeclaration> {
758
+ public_exported_declarations_from(project, |path| is_public_library_entry(&project.root, path))
759
+ }
760
+
761
+ fn public_exported_declarations_from(
762
+ project: &ScannedProject,
763
+ is_public_entry: impl Fn(&Path) -> bool,
764
+ ) -> Vec<PublicExportedDeclaration> {
421
765
  let declarations = declarations_by_path(project);
422
766
  let public_entry_files = project
423
767
  .files
424
768
  .iter()
425
769
  .map(|file| normalize_against(&project.root, &file.path))
426
- .filter(|path| is_public_library_entry(&project.root, path))
770
+ .filter(|path| is_public_entry(path))
427
771
  .collect::<BTreeSet<_>>();
428
772
 
429
773
  let dependencies = project.graph.dependencies();