dart-decimate 0.0.13 → 0.0.14

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.
@@ -1,12 +1,12 @@
1
1
  use std::collections::{BTreeMap, BTreeSet};
2
2
  use std::fs;
3
3
  use std::path::{Path, PathBuf};
4
- use std::process::Command;
5
4
 
6
5
  use petgraph::visit::EdgeRef;
7
6
  use thiserror::Error;
8
7
 
9
8
  use crate::changed_scope::RefSuggestions;
9
+ use crate::git_command;
10
10
  use crate::graph::normalize_against;
11
11
  use crate::output::{FindingKind, JsonReport, JsonSecurityOccurrence, Severity, Verdict};
12
12
  use crate::{ModuleGraph, find_dead_code};
@@ -122,9 +122,8 @@ pub(crate) fn changed_lines_from_git(
122
122
  root: &Path,
123
123
  base: &str,
124
124
  ) -> Result<ChangedLineScope, SecurityGateError> {
125
- let output = Command::new("git")
125
+ let output = git_command::for_repository(root)
126
126
  .args(["diff", "--unified=0", "--diff-filter=ACMRTUXB", base, "--"])
127
- .current_dir(root)
128
127
  .output()
129
128
  .map_err(|source| SecurityGateError::Git { source })?;
130
129
 
@@ -262,9 +261,8 @@ fn add_untracked_lines(
262
261
  base: &str,
263
262
  scope: &mut ChangedLineScope,
264
263
  ) -> Result<(), SecurityGateError> {
265
- let output = Command::new("git")
264
+ let output = git_command::for_repository(root)
266
265
  .args(["ls-files", "--others", "--exclude-standard"])
267
- .current_dir(root)
268
266
  .output()
269
267
  .map_err(|source| SecurityGateError::Git { source })?;
270
268
 
package/src/trace.rs CHANGED
@@ -5,7 +5,8 @@ use std::path::{Path, PathBuf};
5
5
  use serde::{Deserialize, Serialize};
6
6
 
7
7
  use crate::dependencies::{
8
- DeclaredPackageDependency, LocalPubPackage, declared_package_dependencies, local_pub_packages,
8
+ DeclaredPackageDependency, LocalPubPackage, declared_package_dependencies,
9
+ file_uses_codegen_dependency, local_pub_packages,
9
10
  };
10
11
  use crate::dependency_scripts::package_used_in_tooling;
11
12
  use crate::graph::normalize_against;
@@ -93,7 +94,7 @@ pub struct DependencyTraceReport {
93
94
  pub command: String,
94
95
  /// Dependency package being traced.
95
96
  pub dependency: String,
96
- /// Whether the dependency was found as either a declaration or Dart usage.
97
+ /// Whether the dependency was found as either a declaration or usage evidence.
97
98
  pub found: bool,
98
99
  /// Whether the dependency is declared in at least one local pubspec.
99
100
  pub declared: bool,
@@ -107,7 +108,10 @@ pub struct DependencyTraceReport {
107
108
  pub total_import_count: usize,
108
109
  /// Whether non-Dart tooling files reference the package.
109
110
  pub used_in_scripts: bool,
110
- /// Whether Dart source references the package in import/export directives.
111
+ /// Whether Dart source uses the package through a recognized code generator.
112
+ #[serde(default)]
113
+ pub used_in_codegen: bool,
114
+ /// Whether Dart or tooling evidence references the package.
111
115
  pub is_used: bool,
112
116
  /// Short trace interpretation.
113
117
  pub reason: String,
@@ -339,7 +343,11 @@ pub fn trace_dependency(
339
343
  let used_in_scripts = packages
340
344
  .iter()
341
345
  .any(|package| package_used_in_tooling(&package.root, dependency));
342
- let is_used = total_import_count > 0 || used_in_scripts;
346
+ let used_in_codegen = project
347
+ .files
348
+ .iter()
349
+ .any(|file| file_uses_codegen_dependency(file, dependency));
350
+ let is_used = total_import_count > 0 || used_in_scripts || used_in_codegen;
343
351
 
344
352
  Ok(DependencyTraceReport {
345
353
  schema_version: TRACE_SCHEMA_VERSION.to_owned(),
@@ -354,8 +362,9 @@ pub fn trace_dependency(
354
362
  type_only_importers: Vec::new(),
355
363
  total_import_count,
356
364
  used_in_scripts,
365
+ used_in_codegen,
357
366
  is_used,
358
- reason: dependency_reason(declared, is_used),
367
+ reason: dependency_reason(declared, is_used, used_in_codegen),
359
368
  })
360
369
  }
361
370
 
@@ -640,14 +649,14 @@ fn symbol_reason(
640
649
  "symbol has no reachable direct references".to_owned()
641
650
  }
642
651
 
643
- fn dependency_reason(declared: bool, is_used: bool) -> String {
644
- match (declared, is_used) {
645
- (true, true) => "dependency is declared and referenced by Dart import/export directives",
646
- (true, false) => "dependency is declared but no Dart import/export directives reference it",
647
- (false, true) => {
648
- "dependency is referenced by Dart source but not declared in a local pubspec"
649
- }
650
- (false, false) => "dependency is neither declared nor referenced by Dart source",
652
+ fn dependency_reason(declared: bool, is_used: bool, used_in_codegen: bool) -> String {
653
+ match (declared, is_used, used_in_codegen) {
654
+ (true, true, true) => "dependency is declared and has code-generation usage",
655
+ (true, true, false) => "dependency is declared and has usage evidence",
656
+ (true, false, _) => "dependency is declared but has no usage evidence",
657
+ (false, true, true) => "dependency has code-generation usage but is not declared",
658
+ (false, true, false) => "dependency has usage evidence but is not declared",
659
+ (false, false, _) => "dependency is neither declared nor supported by usage evidence",
651
660
  }
652
661
  .to_owned()
653
662
  }
@@ -0,0 +1,250 @@
1
+ use std::collections::{BTreeMap, BTreeSet};
2
+ use std::path::{Path, PathBuf};
3
+
4
+ use tree_sitter::Node;
5
+
6
+ use super::params::constructor_params;
7
+ use super::patterns::class_member_names;
8
+ use super::reads::{WidgetMemberRead, WidgetMemberReceiver, widget_body_member_reads};
9
+ use super::resolution::{ClassKey, DeclarationResolver};
10
+ use super::{WidgetFileFacts, simple_type_name, superclass_type_text, widget_kind};
11
+
12
+ #[derive(Debug)]
13
+ pub(super) struct ProjectClassFact {
14
+ pub(super) path: PathBuf,
15
+ pub(super) name: String,
16
+ pub(super) superclass: Option<String>,
17
+ pub(super) widget_params: BTreeSet<(String, String)>,
18
+ member_names: BTreeSet<String>,
19
+ body_member_reads: BTreeSet<WidgetMemberRead>,
20
+ }
21
+
22
+ pub(super) fn inherited_param_uses_across_files(
23
+ files: &[WidgetFileFacts],
24
+ resolver: &DeclarationResolver,
25
+ ) -> BTreeSet<(PathBuf, String, String)> {
26
+ let facts = files
27
+ .iter()
28
+ .flat_map(|file| file.classes.iter())
29
+ .collect::<Vec<_>>();
30
+ let facts_by_key = facts
31
+ .iter()
32
+ .map(|fact| (fact.class_key(), *fact))
33
+ .collect::<BTreeMap<_, _>>();
34
+ let mut uses = BTreeSet::new();
35
+ for file in files {
36
+ collect_file_inherited_uses(file, &facts_by_key, resolver, &mut uses);
37
+ }
38
+ uses
39
+ }
40
+
41
+ pub(super) fn class_facts(
42
+ path: &Path,
43
+ classes: &[Node<'_>],
44
+ source: &str,
45
+ ) -> Vec<ProjectClassFact> {
46
+ classes
47
+ .iter()
48
+ .filter_map(|class| {
49
+ let name = class_name(*class, source)?;
50
+ let widget_params = widget_kind(*class, source)
51
+ .map(|_| {
52
+ constructor_params(*class, &name, source)
53
+ .into_iter()
54
+ .map(|param| (param.field_name, param.name))
55
+ .collect()
56
+ })
57
+ .unwrap_or_default();
58
+ Some(ProjectClassFact {
59
+ path: path.to_path_buf(),
60
+ name,
61
+ superclass: superclass_type_text(*class, source),
62
+ widget_params,
63
+ member_names: class_member_names(*class, source),
64
+ body_member_reads: class
65
+ .child_by_field_name("body")
66
+ .map_or_else(BTreeSet::new, |body| widget_body_member_reads(body, source)),
67
+ })
68
+ })
69
+ .collect()
70
+ }
71
+
72
+ fn collect_file_inherited_uses(
73
+ file: &WidgetFileFacts,
74
+ facts: &BTreeMap<ClassKey, &ProjectClassFact>,
75
+ resolver: &DeclarationResolver,
76
+ uses: &mut BTreeSet<(PathBuf, String, String)>,
77
+ ) {
78
+ for class in &file.classes {
79
+ let mut pending = class
80
+ .superclass
81
+ .iter()
82
+ .map(|parent| (class.path.clone(), parent.clone()))
83
+ .collect::<Vec<_>>();
84
+ let mut visited = BTreeSet::new();
85
+ while let Some((current_path, parent_name)) = pending.pop() {
86
+ for ancestor_key in resolver.resolve(&current_path, &parent_name) {
87
+ if !visited.insert(ancestor_key.clone()) {
88
+ continue;
89
+ }
90
+ let Some(ancestor) = facts.get(&ancestor_key) else {
91
+ continue;
92
+ };
93
+ for (field_name, param_name) in &ancestor.widget_params {
94
+ if class.body_member_reads.iter().any(|read| {
95
+ read.name == *field_name
96
+ && member_owner_for_read(class, read, facts, resolver)
97
+ .is_some_and(|owner| owner == ancestor_key)
98
+ }) {
99
+ uses.insert((
100
+ ancestor.path.clone(),
101
+ ancestor.name.clone(),
102
+ param_name.clone(),
103
+ ));
104
+ }
105
+ }
106
+ if let Some(parent) = &ancestor.superclass {
107
+ pending.push((ancestor.path.clone(), parent.clone()));
108
+ }
109
+ }
110
+ }
111
+ }
112
+ }
113
+
114
+ impl ProjectClassFact {
115
+ fn class_key(&self) -> ClassKey {
116
+ ClassKey {
117
+ path: self.path.clone(),
118
+ name: self.name.clone(),
119
+ }
120
+ }
121
+ }
122
+
123
+ pub(super) fn class_superclasses(classes: &[Node<'_>], source: &str) -> BTreeMap<String, String> {
124
+ classes
125
+ .iter()
126
+ .filter_map(|class| {
127
+ Some((
128
+ class_name(*class, source)?,
129
+ superclass_type_text(*class, source)?,
130
+ ))
131
+ })
132
+ .collect()
133
+ }
134
+
135
+ pub(super) fn inherited_param_uses(
136
+ classes: &[Node<'_>],
137
+ source: &str,
138
+ ) -> BTreeSet<(String, String)> {
139
+ let superclasses = class_superclasses(classes, source);
140
+ let facts = class_facts(Path::new(""), classes, source);
141
+ let facts_by_name = facts
142
+ .iter()
143
+ .map(|fact| (fact.name.clone(), fact))
144
+ .collect::<BTreeMap<_, _>>();
145
+ let mut uses = BTreeSet::new();
146
+
147
+ for fact in &facts {
148
+ for read in &fact.body_member_reads {
149
+ let Some(owner) = local_member_owner(&fact.name, read, &facts_by_name, &superclasses)
150
+ else {
151
+ continue;
152
+ };
153
+ if owner == fact.name {
154
+ continue;
155
+ }
156
+ let Some(owner_fact) = facts_by_name.get(&owner) else {
157
+ continue;
158
+ };
159
+ for (field_name, param_name) in &owner_fact.widget_params {
160
+ if field_name == &read.name {
161
+ uses.insert((owner.clone(), param_name.clone()));
162
+ }
163
+ }
164
+ }
165
+ }
166
+
167
+ uses
168
+ }
169
+
170
+ fn class_name(class: Node<'_>, source: &str) -> Option<String> {
171
+ class
172
+ .child_by_field_name("name")?
173
+ .utf8_text(source.as_bytes())
174
+ .ok()
175
+ .map(simple_type_name)
176
+ }
177
+
178
+ fn member_owner_for_read(
179
+ class: &ProjectClassFact,
180
+ read: &WidgetMemberRead,
181
+ facts: &BTreeMap<ClassKey, &ProjectClassFact>,
182
+ resolver: &DeclarationResolver,
183
+ ) -> Option<ClassKey> {
184
+ let start = match read.receiver {
185
+ WidgetMemberReceiver::Implicit | WidgetMemberReceiver::This => class.class_key(),
186
+ WidgetMemberReceiver::Super => resolved_superclass(class, facts, resolver)?,
187
+ };
188
+ resolved_member_owner(start, &read.name, facts, resolver, &mut BTreeSet::new())
189
+ }
190
+
191
+ fn resolved_superclass(
192
+ class: &ProjectClassFact,
193
+ facts: &BTreeMap<ClassKey, &ProjectClassFact>,
194
+ resolver: &DeclarationResolver,
195
+ ) -> Option<ClassKey> {
196
+ let parent = class.superclass.as_deref()?;
197
+ let candidates = resolver.resolve(&class.path, parent);
198
+ let key = candidates.first()?.clone();
199
+ (candidates.len() == 1 && facts.contains_key(&key)).then_some(key)
200
+ }
201
+
202
+ fn resolved_member_owner(
203
+ class_key: ClassKey,
204
+ name: &str,
205
+ facts: &BTreeMap<ClassKey, &ProjectClassFact>,
206
+ resolver: &DeclarationResolver,
207
+ visited: &mut BTreeSet<ClassKey>,
208
+ ) -> Option<ClassKey> {
209
+ if !visited.insert(class_key.clone()) {
210
+ return None;
211
+ }
212
+ let class = facts.get(&class_key)?;
213
+ if class.member_names.contains(name) {
214
+ return Some(class_key);
215
+ }
216
+ let parent = class.superclass.as_deref()?;
217
+ let candidates = resolver.resolve(&class.path, parent);
218
+ let key = candidates.first()?.clone();
219
+ (candidates.len() == 1).then(|| resolved_member_owner(key, name, facts, resolver, visited))?
220
+ }
221
+
222
+ fn local_member_owner(
223
+ class_name: &str,
224
+ read: &WidgetMemberRead,
225
+ facts: &BTreeMap<String, &ProjectClassFact>,
226
+ superclasses: &BTreeMap<String, String>,
227
+ ) -> Option<String> {
228
+ let start = match read.receiver {
229
+ WidgetMemberReceiver::Implicit | WidgetMemberReceiver::This => class_name.to_owned(),
230
+ WidgetMemberReceiver::Super => simple_type_name(superclasses.get(class_name)?),
231
+ };
232
+ local_member_owner_from(&start, &read.name, facts, &mut BTreeSet::new())
233
+ }
234
+
235
+ fn local_member_owner_from(
236
+ class_name: &str,
237
+ name: &str,
238
+ facts: &BTreeMap<String, &ProjectClassFact>,
239
+ visited: &mut BTreeSet<String>,
240
+ ) -> Option<String> {
241
+ if !visited.insert(class_name.to_owned()) {
242
+ return None;
243
+ }
244
+ let class = facts.get(class_name)?;
245
+ if class.member_names.contains(name) {
246
+ return Some(class_name.to_owned());
247
+ }
248
+ let parent = simple_type_name(class.superclass.as_deref()?);
249
+ local_member_owner_from(&parent, name, facts, visited)
250
+ }
@@ -2,6 +2,7 @@ use std::collections::BTreeMap;
2
2
 
3
3
  use tree_sitter::Node;
4
4
 
5
+ use super::reads::direct_identifier_shadowed_before;
5
6
  use crate::Location;
6
7
 
7
8
  #[derive(Debug, Clone, PartialEq, Eq)]
@@ -49,6 +50,74 @@ pub(super) fn constructor_params(
49
50
  params.into_values().collect()
50
51
  }
51
52
 
53
+ pub(super) fn constructor_initializers_use_param(
54
+ class: Node<'_>,
55
+ widget_class: &str,
56
+ field_name: &str,
57
+ param_name: &str,
58
+ source: &str,
59
+ ) -> bool {
60
+ let mut declarations = Vec::new();
61
+ collect_nodes_in(class, &["declaration"], &mut declarations);
62
+ declarations.into_iter().any(|declaration| {
63
+ let Some(signature) = constructor_signature(declaration) else {
64
+ return false;
65
+ };
66
+ if constructor_owner(signature, source).as_deref() != Some(widget_class) {
67
+ return false;
68
+ }
69
+ let mut entries = Vec::new();
70
+ collect_nodes(declaration, "initializer_list_entry", &mut entries);
71
+ entries
72
+ .into_iter()
73
+ .any(|entry| initializer_entry_uses_param(entry, field_name, param_name, source))
74
+ })
75
+ }
76
+
77
+ fn initializer_entry_uses_param(
78
+ entry: Node<'_>,
79
+ field_name: &str,
80
+ param_name: &str,
81
+ source: &str,
82
+ ) -> bool {
83
+ let mut cursor = entry.walk();
84
+ entry.named_children(&mut cursor).any(|initializer| {
85
+ if initializer.kind() == "assertion" {
86
+ return initializer_value_uses_param(initializer, param_name, source);
87
+ }
88
+ if initializer.kind() != "field_initializer" {
89
+ return false;
90
+ }
91
+ let mut cursor = initializer.walk();
92
+ initializer
93
+ .children_by_field_name("value", &mut cursor)
94
+ .any(|value| {
95
+ initializer_value_uses_param(value, param_name, source)
96
+ && !initializer_is_direct_assignment(
97
+ initializer,
98
+ field_name,
99
+ param_name,
100
+ source,
101
+ )
102
+ })
103
+ })
104
+ }
105
+
106
+ fn initializer_is_direct_assignment(
107
+ initializer: Node<'_>,
108
+ field_name: &str,
109
+ param_name: &str,
110
+ source: &str,
111
+ ) -> bool {
112
+ field_text(initializer, "name", source).as_deref() == Some(field_name)
113
+ && initializer
114
+ .child_by_field_name("value")
115
+ .is_some_and(|value| {
116
+ value.kind() == "identifier"
117
+ && value.utf8_text(source.as_bytes()).ok() == Some(param_name)
118
+ })
119
+ }
120
+
52
121
  const CONSTRUCTOR_SIGNATURES: &[&str] =
53
122
  &["constructor_signature", "constant_constructor_signature"];
54
123
 
@@ -165,18 +234,29 @@ fn initialized_field_from_param(
165
234
  }
166
235
 
167
236
  fn initializer_value_uses_param(node: Node<'_>, name: &str, source: &str) -> bool {
237
+ let boundary = node.parent().unwrap_or(node);
238
+ initializer_node_uses_param(boundary, node, name, source)
239
+ }
240
+
241
+ fn initializer_node_uses_param(
242
+ boundary: Node<'_>,
243
+ node: Node<'_>,
244
+ name: &str,
245
+ source: &str,
246
+ ) -> bool {
168
247
  if matches!(node.kind(), "identifier" | "identifier_dollar_escaped")
169
248
  && node.utf8_text(source.as_bytes()).ok() == Some(name)
170
249
  && node.parent().is_none_or(|parent| {
171
250
  !field_contains_node(parent, "name", node)
172
251
  && !field_contains_node(parent, "property", node)
173
252
  })
253
+ && !direct_identifier_shadowed_before(boundary, node, name, source)
174
254
  {
175
255
  return true;
176
256
  }
177
257
  let mut cursor = node.walk();
178
258
  node.named_children(&mut cursor)
179
- .any(|child| initializer_value_uses_param(child, name, source))
259
+ .any(|child| initializer_node_uses_param(boundary, child, name, source))
180
260
  }
181
261
 
182
262
  fn collect_nodes_in<'tree>(node: Node<'tree>, kinds: &[&str], nodes: &mut Vec<Node<'tree>>) {
@@ -2058,38 +2058,45 @@ fn root_node(mut node: Node<'_>) -> Node<'_> {
2058
2058
  node
2059
2059
  }
2060
2060
 
2061
- fn class_declares_member(class: Node<'_>, name: &str, source: &str) -> bool {
2061
+ pub(super) fn class_member_names(class: Node<'_>, source: &str) -> BTreeSet<String> {
2062
2062
  let Some(body) = class.child_by_field_name("body") else {
2063
- return false;
2063
+ return BTreeSet::new();
2064
2064
  };
2065
+ let mut names = BTreeSet::new();
2065
2066
  let mut cursor = body.walk();
2066
- body.named_children(&mut cursor)
2067
- .any(|child| match child.kind() {
2068
- "class_member" => class_member_declares_name(child, name, source),
2069
- "method_declaration" => member_signature_name(child, source).as_deref() == Some(name),
2070
- "declaration" => declaration_declares_member(child, name, source),
2071
- _ => false,
2072
- })
2067
+ for child in body.named_children(&mut cursor) {
2068
+ collect_class_member_names(child, source, &mut names);
2069
+ }
2070
+ names
2073
2071
  }
2074
2072
 
2075
- fn class_member_declares_name(member: Node<'_>, name: &str, source: &str) -> bool {
2076
- let mut cursor = member.walk();
2077
- member
2078
- .named_children(&mut cursor)
2079
- .any(|child| match child.kind() {
2080
- "method_declaration" => member_signature_name(child, source).as_deref() == Some(name),
2081
- "declaration" => declaration_declares_member(child, name, source),
2082
- _ => false,
2083
- })
2073
+ fn collect_class_member_names(node: Node<'_>, source: &str, names: &mut BTreeSet<String>) {
2074
+ match node.kind() {
2075
+ "class_member" => {
2076
+ let mut cursor = node.walk();
2077
+ for child in node.named_children(&mut cursor) {
2078
+ collect_class_member_names(child, source, names);
2079
+ }
2080
+ }
2081
+ "method_declaration" => {
2082
+ if let Some(name) = member_signature_name(node, source) {
2083
+ names.insert(name);
2084
+ }
2085
+ }
2086
+ "declaration" => {
2087
+ if let Some(name) = member_signature_name(node, source) {
2088
+ names.insert(name);
2089
+ }
2090
+ let mut fields = Vec::new();
2091
+ collect_member_field_names(node, source, &mut fields);
2092
+ names.extend(fields);
2093
+ }
2094
+ _ => {}
2095
+ }
2084
2096
  }
2085
2097
 
2086
- fn declaration_declares_member(declaration: Node<'_>, name: &str, source: &str) -> bool {
2087
- if member_signature_name(declaration, source).as_deref() == Some(name) {
2088
- return true;
2089
- }
2090
- let mut names = Vec::new();
2091
- collect_member_field_names(declaration, source, &mut names);
2092
- names.iter().any(|candidate| candidate == name)
2098
+ fn class_declares_member(class: Node<'_>, name: &str, source: &str) -> bool {
2099
+ class_member_names(class, source).contains(name)
2093
2100
  }
2094
2101
 
2095
2102
  fn member_signature_name(node: Node<'_>, source: &str) -> Option<String> {
@@ -1,7 +1,22 @@
1
+ use std::collections::BTreeSet;
2
+
1
3
  use tree_sitter::Node;
2
4
 
3
5
  use super::patterns::{declaration_binds_name, pattern_binds_name};
4
6
 
7
+ #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
8
+ pub(super) enum WidgetMemberReceiver {
9
+ Implicit,
10
+ This,
11
+ Super,
12
+ }
13
+
14
+ #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
15
+ pub(super) struct WidgetMemberRead {
16
+ pub(super) name: String,
17
+ pub(super) receiver: WidgetMemberReceiver,
18
+ }
19
+
5
20
  pub(super) fn widget_body_uses_param(body: Node<'_>, name: &str, source: &str) -> bool {
6
21
  let mut found = false;
7
22
  visit_named(body, &mut |node| {
@@ -15,6 +30,32 @@ pub(super) fn widget_body_uses_param(body: Node<'_>, name: &str, source: &str) -
15
30
  found
16
31
  }
17
32
 
33
+ pub(super) fn widget_body_member_reads(body: Node<'_>, source: &str) -> BTreeSet<WidgetMemberRead> {
34
+ let mut reads = BTreeSet::new();
35
+ visit_named(body, &mut |node| {
36
+ if let Some(name) = receiver_member_name(node, &["super"], source) {
37
+ reads.insert(WidgetMemberRead {
38
+ name,
39
+ receiver: WidgetMemberReceiver::Super,
40
+ });
41
+ } else if let Some(name) = receiver_member_name(node, &["this"], source) {
42
+ reads.insert(WidgetMemberRead {
43
+ name,
44
+ receiver: WidgetMemberReceiver::This,
45
+ });
46
+ } else if matches!(node.kind(), "identifier" | "identifier_dollar_escaped")
47
+ && let Ok(name) = node.utf8_text(source.as_bytes())
48
+ && is_body_identifier_use(node, name, source)
49
+ {
50
+ reads.insert(WidgetMemberRead {
51
+ name: name.to_owned(),
52
+ receiver: WidgetMemberReceiver::Implicit,
53
+ });
54
+ }
55
+ });
56
+ reads
57
+ }
58
+
18
59
  fn is_body_identifier_use(node: Node<'_>, name: &str, source: &str) -> bool {
19
60
  if !matches!(node.kind(), "identifier" | "identifier_dollar_escaped") {
20
61
  return false;
@@ -157,22 +198,31 @@ fn identifier_before_parameters(node: Node<'_>, source: &str) -> Option<String>
157
198
  }
158
199
 
159
200
  fn is_this_member_access(node: Node<'_>, name: &str, source: &str) -> bool {
201
+ this_member_name(node, source).as_deref() == Some(name)
202
+ }
203
+
204
+ fn this_member_name(node: Node<'_>, source: &str) -> Option<String> {
205
+ receiver_member_name(node, &["this"], source)
206
+ }
207
+
208
+ fn receiver_member_name(node: Node<'_>, receivers: &[&str], source: &str) -> Option<String> {
160
209
  if !matches!(
161
210
  node.kind(),
162
211
  "member_expression" | "null_aware_member_expression" | "assignable_expression"
163
212
  ) {
164
- return false;
165
- }
166
- let Some(property) = node.child_by_field_name("property") else {
167
- return false;
168
- };
169
- if property.utf8_text(source.as_bytes()).ok() != Some(name) {
170
- return false;
213
+ return None;
171
214
  }
172
- let Some(object) = node.child_by_field_name("object") else {
173
- return false;
174
- };
175
- object.utf8_text(source.as_bytes()).ok() == Some("this")
215
+ let property = node.child_by_field_name("property")?;
216
+ let object = node.child_by_field_name("object")?;
217
+ receivers
218
+ .contains(&object.utf8_text(source.as_bytes()).ok()?)
219
+ .then(|| {
220
+ property
221
+ .utf8_text(source.as_bytes())
222
+ .ok()
223
+ .map(str::to_owned)
224
+ })
225
+ .flatten()
176
226
  }
177
227
 
178
228
  pub(super) fn direct_identifier_shadowed_before(