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 +1 -1
- package/Cargo.toml +1 -1
- package/README.md +2 -2
- package/package.json +1 -1
- package/src/dependencies/analyze.rs +94 -11
- package/src/dependencies.rs +7 -1
- package/src/output/route_cycle/navigation.rs +150 -22
- package/src/output/route_cycle.rs +4 -1
package/Cargo.lock
CHANGED
package/Cargo.toml
CHANGED
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.
|
|
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.
|
|
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,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::
|
|
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
|
|
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(
|
|
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
|
}
|
package/src/dependencies.rs
CHANGED
|
@@ -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,
|
|
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(
|
|
46
|
-
.is_some_and(|
|
|
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
|
-
|
|
62
|
-
|
|
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
|
|
325
|
+
fn navigation_expression_resolution(
|
|
329
326
|
root: Node<'_>,
|
|
330
327
|
site: Node<'_>,
|
|
331
|
-
|
|
332
|
-
|
|
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
|
|
336
|
-
|
|
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
|
-
|
|
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
|
|
615
|
-
let
|
|
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
|
-
|
|
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
|
|
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)
|