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.
- package/Cargo.lock +75 -1
- package/Cargo.toml +2 -1
- package/README.md +22 -27
- package/npm/scripts/postinstall.js +33 -12
- package/npm/scripts/test-npx-local.js +7 -2
- package/npm/scripts/test-npx-mcp-local.js +3 -1
- package/npm/scripts/test-npx-prebuilt.js +33 -13
- package/npm/scripts/test-postinstall-prebuilt.js +33 -13
- package/package.json +9 -3
- package/src/changed_scope.rs +4 -7
- package/src/cli/audit_run.rs +1 -3
- package/src/cli/decision_surface_run.rs +1 -3
- package/src/cli/entry_points.rs +75 -13
- package/src/dart_parser.rs +1 -3
- package/src/dependencies/codegen.rs +26 -0
- package/src/dependencies.rs +1 -0
- package/src/dependency_scripts.rs +42 -8
- package/src/extract.rs +6 -0
- package/src/git_command.rs +58 -0
- package/src/graph.rs +5 -0
- package/src/lib.rs +1 -0
- package/src/manifest.rs +1 -1
- package/src/scan/tests.rs +133 -0
- package/src/scan.rs +122 -47
- package/src/security/detect.rs +1275 -10
- package/src/security_gate.rs +3 -5
- package/src/trace.rs +22 -13
- package/src/widgets/inheritance.rs +250 -0
- package/src/widgets/params.rs +81 -1
- package/src/widgets/patterns.rs +32 -25
- package/src/widgets/reads.rs +61 -11
- package/src/widgets/resolution.rs +281 -0
- package/src/widgets/unrendered.rs +111 -47
- package/src/widgets.rs +69 -11
package/src/security_gate.rs
CHANGED
|
@@ -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 =
|
|
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 =
|
|
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,
|
|
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
|
|
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
|
|
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
|
|
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
|
|
646
|
-
(true, false) => "dependency is declared
|
|
647
|
-
(false,
|
|
648
|
-
|
|
649
|
-
|
|
650
|
-
(false, false) => "dependency is neither declared nor
|
|
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(¤t_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
|
+
}
|
package/src/widgets/params.rs
CHANGED
|
@@ -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|
|
|
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>>) {
|
package/src/widgets/patterns.rs
CHANGED
|
@@ -2058,38 +2058,45 @@ fn root_node(mut node: Node<'_>) -> Node<'_> {
|
|
|
2058
2058
|
node
|
|
2059
2059
|
}
|
|
2060
2060
|
|
|
2061
|
-
fn
|
|
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
|
|
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
|
-
|
|
2068
|
-
|
|
2069
|
-
|
|
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
|
|
2076
|
-
|
|
2077
|
-
|
|
2078
|
-
|
|
2079
|
-
|
|
2080
|
-
|
|
2081
|
-
|
|
2082
|
-
|
|
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
|
|
2087
|
-
|
|
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> {
|
package/src/widgets/reads.rs
CHANGED
|
@@ -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
|
|
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
|
|
173
|
-
|
|
174
|
-
|
|
175
|
-
|
|
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(
|