@inthedark/dxlint 0.0.0-stage → 0.1.0
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/LICENSE +21 -0
- package/README.md +84 -2
- package/bin/dxlint +15 -0
- package/bin/dxlint-linux-x64 +0 -0
- package/bin/dxlint-win32-x64.exe +0 -0
- package/package.json +29 -4
- package/rules/conventions.dx +34 -0
- package/rules/correctness.dx +33 -0
- package/rules/es-no-semi.dx +11 -0
- package/rules/format.dx +49 -0
- package/rules/recommended.dx +51 -0
- package/rules/suspicious.dx +31 -0
- package/rules/types.dx +21 -0
- package/std/c.dx +23 -0
- package/std/core/lines.dx +51 -0
- package/std/core/lists.dx +76 -0
- package/std/core.dx +30 -0
- package/std/css.dx +17 -0
- package/std/dx.dx +31 -0
- package/std/json.dx +104 -0
- package/std/markdown.dx +11 -0
- package/std/python.dx +21 -0
- package/std/rust/format.dx +316 -0
- package/std/rust.dx +34 -0
- package/std/toml.dx +19 -0
- package/std/ts/arithmetic.dx +87 -0
- package/std/ts/assertions.dx +477 -0
- package/std/ts/calls.dx +246 -0
- package/std/ts/comments.dx +10 -0
- package/std/ts/conditions.dx +531 -0
- package/std/ts/constants.dx +335 -0
- package/std/ts/deprecation.dx +185 -0
- package/std/ts/directives.dx +60 -0
- package/std/ts/effects.dx +219 -0
- package/std/ts/enums.dx +233 -0
- package/std/ts/expression-fixes.dx +67 -0
- package/std/ts/expressions.dx +270 -0
- package/std/ts/flow.dx +2 -0
- package/std/ts/format.dx +755 -0
- package/std/ts/globals.dx +106 -0
- package/std/ts/grammar.dx +488 -0
- package/std/ts/helpers.dx +102 -0
- package/std/ts/import-attributes.dx +88 -0
- package/std/ts/import-no-deprecated.dx +73 -0
- package/std/ts/indentation.dx +442 -0
- package/std/ts/jsx.dx +646 -0
- package/std/ts/layout/blocks.dx +281 -0
- package/std/ts/layout/calls.dx +79 -0
- package/std/ts/layout/expressions.dx +213 -0
- package/std/ts/layout/literals.dx +114 -0
- package/std/ts/layout/separators.dx +184 -0
- package/std/ts/layout/shared.dx +203 -0
- package/std/ts/layout/text.dx +142 -0
- package/std/ts/layout/types.dx +182 -0
- package/std/ts/layout.dx +9 -0
- package/std/ts/license.dx +54 -0
- package/std/ts/literal-text.dx +3 -0
- package/std/ts/literals.dx +95 -0
- package/std/ts/methods.dx +69 -0
- package/std/ts/modules.dx +268 -0
- package/std/ts/names.dx +348 -0
- package/std/ts/naming.dx +169 -0
- package/std/ts/narrowing.dx +96 -0
- package/std/ts/parentheses.dx +262 -0
- package/std/ts/precedence.dx +25 -0
- package/std/ts/problems/calls.dx +34 -0
- package/std/ts/problems/classes.dx +39 -0
- package/std/ts/problems/control-flow.dx +257 -0
- package/std/ts/problems/declarations.dx +67 -0
- package/std/ts/problems/duplicates.dx +70 -0
- package/std/ts/problems/expressions.dx +154 -0
- package/std/ts/problems/helpers.dx +22 -0
- package/std/ts/problems/imports.dx +43 -0
- package/std/ts/problems/non-null.dx +78 -0
- package/std/ts/problems/numeric-precision.dx +66 -0
- package/std/ts/problems/regexp.dx +66 -0
- package/std/ts/problems/statements.dx +36 -0
- package/std/ts/problems/typescript.dx +55 -0
- package/std/ts/problems/whitespace.dx +40 -0
- package/std/ts/problems.dx +20 -0
- package/std/ts/regex/checks.dx +249 -0
- package/std/ts/regex/findings.dx +209 -0
- package/std/ts/regex/grammar.dx +80 -0
- package/std/ts/regex/suggestions.dx +94 -0
- package/std/ts/regex/values.dx +378 -0
- package/std/ts/regex.dx +5 -0
- package/std/ts/restrictions/comments.dx +76 -0
- package/std/ts/restrictions.dx +811 -0
- package/std/ts/scopes.dx +68 -0
- package/std/ts/scoping/atomic.dx +40 -0
- package/std/ts/scoping/bindings.dx +126 -0
- package/std/ts/scoping/constness.dx +72 -0
- package/std/ts/scoping/globals.dx +52 -0
- package/std/ts/scoping/loops.dx +86 -0
- package/std/ts/scoping/member-uses.dx +111 -0
- package/std/ts/scoping/receivers.dx +107 -0
- package/std/ts/scoping/shadowing.dx +202 -0
- package/std/ts/scoping/usage.dx +393 -0
- package/std/ts/scoping.dx +842 -0
- package/std/ts/selectors.dx +10 -0
- package/std/ts/spreads.dx +97 -0
- package/std/ts/structure/declarations.dx +52 -0
- package/std/ts/structure/lines.dx +79 -0
- package/std/ts/structure/lists.dx +144 -0
- package/std/ts/structure/padding.dx +258 -0
- package/std/ts/structure.dx +963 -0
- package/std/ts/style/classes.dx +157 -0
- package/std/ts/style/comments.dx +75 -0
- package/std/ts/style/declarations.dx +82 -0
- package/std/ts/style/expressions.dx +125 -0
- package/std/ts/style/imports.dx +44 -0
- package/std/ts/style/ordering.dx +192 -0
- package/std/ts/style/returns.dx +152 -0
- package/std/ts/style/signatures.dx +308 -0
- package/std/ts/style/type-exports.dx +62 -0
- package/std/ts/style/type-imports.dx +166 -0
- package/std/ts/style/types.dx +474 -0
- package/std/ts/style.dx +29 -0
- package/std/ts/suggestions/accessors.dx +138 -0
- package/std/ts/suggestions/builtins.dx +110 -0
- package/std/ts/suggestions/comparisons.dx +41 -0
- package/std/ts/suggestions/computed-keys.dx +20 -0
- package/std/ts/suggestions/constructors.dx +54 -0
- package/std/ts/suggestions/control-flow.dx +204 -0
- package/std/ts/suggestions/curly.dx +124 -0
- package/std/ts/suggestions/directives.dx +79 -0
- package/std/ts/suggestions/errors.dx +106 -0
- package/std/ts/suggestions/expressions.dx +230 -0
- package/std/ts/suggestions/functions.dx +260 -0
- package/std/ts/suggestions/globals.dx +187 -0
- package/std/ts/suggestions/helpers.dx +17 -0
- package/std/ts/suggestions/object-shorthand.dx +148 -0
- package/std/ts/suggestions/object-spread.dx +96 -0
- package/std/ts/suggestions/regexp.dx +59 -0
- package/std/ts/suggestions/renames.dx +50 -0
- package/std/ts/suggestions/strings.dx +47 -0
- package/std/ts/suggestions/templates.dx +104 -0
- package/std/ts/suggestions.dx +24 -0
- package/std/ts/template-fixes.dx +22 -0
- package/std/ts/tokens.dx +124 -0
- package/std/ts/type-specifiers.dx +93 -0
- package/std/ts/typed/assignments.dx +154 -0
- package/std/ts/typed/awaitability.dx +157 -0
- package/std/ts/typed/boolean-comparisons.dx +82 -0
- package/std/ts/typed/defaults.dx +97 -0
- package/std/ts/typed/enum-consistency.dx +68 -0
- package/std/ts/typed/enums.dx +52 -0
- package/std/ts/typed/errors.dx +32 -0
- package/std/ts/typed/floating-promises.dx +147 -0
- package/std/ts/typed/for-in-arrays.dx +21 -0
- package/std/ts/typed/includes.dx +102 -0
- package/std/ts/typed/nullish-coalescing.dx +149 -0
- package/std/ts/typed/optional-chains.dx +317 -0
- package/std/ts/typed/promises.dx +205 -0
- package/std/ts/typed/qualifiers.dx +108 -0
- package/std/ts/typed/readonly-members.dx +159 -0
- package/std/ts/typed/readonly-parameters.dx +121 -0
- package/std/ts/typed/redundant-constituents.dx +171 -0
- package/std/ts/typed/regexp-exec.dx +79 -0
- package/std/ts/typed/rejection-handlers.dx +91 -0
- package/std/ts/typed/return-await.dx +116 -0
- package/std/ts/typed/return-this.dx +67 -0
- package/std/ts/typed/strict-void-return.dx +121 -0
- package/std/ts/typed/string-boundaries.dx +153 -0
- package/std/ts/typed/switches.dx +147 -0
- package/std/ts/typed/template-expressions.dx +127 -0
- package/std/ts/typed/template-values.dx +88 -0
- package/std/ts/typed/transfers.dx +106 -0
- package/std/ts/typed/type-arguments.dx +337 -0
- package/std/ts/typed/type-constituents.dx +143 -0
- package/std/ts/typed/type-conversions.dx +82 -0
- package/std/ts/typed/type-parameters.dx +280 -0
- package/std/ts/typed/unbound-method.dx +167 -0
- package/std/ts/typed/unsafe-calls.dx +73 -0
- package/std/ts/typed/unsafe-members.dx +36 -0
- package/std/ts/typed/void-expressions.dx +101 -0
- package/std/ts/typed.dx +585 -0
- package/std/ts/values/arguments.dx +13 -0
- package/std/ts/values/enums.dx +104 -0
- package/std/ts/values/inspection.dx +274 -0
- package/std/ts/values.dx +1217 -0
- package/std/ts.dx +77 -0
- package/std/whitespace.dx +37 -0
|
@@ -0,0 +1,393 @@
|
|
|
1
|
+
import .ts/scoping/bindings
|
|
2
|
+
import .ts/names
|
|
3
|
+
import .ts/globals
|
|
4
|
+
import .ts/helpers
|
|
5
|
+
|
|
6
|
+
define {
|
|
7
|
+
|
|
8
|
+
group ts_usage_jsx ts_jsx_element, ts_jsx_fragment
|
|
9
|
+
group ts_usage_iteration ts_for_in, ts_for_of
|
|
10
|
+
in ts_program let ts_usage_jsx_present count(descendants(ts_usage_jsx)) > 0
|
|
11
|
+
in ts_program let ts_usage_jsx_bindings if !ts_usage_jsx_present then [] else {
|
|
12
|
+
value fragment: count(descendants(ts_jsx_fragment)) > 0
|
|
13
|
+
value fragments: if fragment then [program_option(node, "jsxFragmentFactory") ?? "React.Fragment"] else []
|
|
14
|
+
value [program_option(node, "jsxFactory") ?? "React.createElement"] fragments
|
|
15
|
+
filter (factory) type_of(factory) == "str"
|
|
16
|
+
map (factory) first(split(factory, "."))
|
|
17
|
+
unique
|
|
18
|
+
}
|
|
19
|
+
fn ts_usage_jsx_used(binding, program) = binding != null
|
|
20
|
+
&& binding.scope.id == last(program.scoping_lexical_scopes).id
|
|
21
|
+
&& contains(program.ts_usage_jsx_bindings, first(binding.declarations).text)
|
|
22
|
+
in ts_program let ts_usage_return_bindings {
|
|
23
|
+
value descendants(ts_usage_iteration)
|
|
24
|
+
filter (loop) {
|
|
25
|
+
value body: loop.body.node
|
|
26
|
+
value statements: if body is ts_block then body.body.nodes else [body]
|
|
27
|
+
value count(statements) == 1 && first(statements) is ts_return
|
|
28
|
+
}
|
|
29
|
+
map (loop) {
|
|
30
|
+
value left: unparenthesised_node(loop.left.node)
|
|
31
|
+
value declarator: { value left.children.nodes; filter (child) child is ts_declarator; first }
|
|
32
|
+
value target: if left is ts_variable_declaration then declarator.name.node else left
|
|
33
|
+
value if target is ts_identifier then name_binding(target).node else null
|
|
34
|
+
}
|
|
35
|
+
filter (binding) binding != null
|
|
36
|
+
unique
|
|
37
|
+
}
|
|
38
|
+
fn ts_usage_parent(n) = outer_parenthesised_node(n).parent.node
|
|
39
|
+
fn ts_usage_pattern_parent(n) = if n.parent is (ts_array_pattern, ts_object_pattern, ts_pattern_property, ts_assignment_pattern, ts_rest)
|
|
40
|
+
then n.parent.node else null
|
|
41
|
+
fn ts_usage_site(n) = {
|
|
42
|
+
value pattern: { value n; walk (current) ts_usage_pattern_parent(current); last }
|
|
43
|
+
value parent: pattern.parent.node
|
|
44
|
+
value if parent is ts_declarator then parent.parent.node else parent
|
|
45
|
+
}
|
|
46
|
+
fn ts_usage_function(n) = {
|
|
47
|
+
value parameter: {
|
|
48
|
+
value walk(n.parent.node, current => current.parent.node)
|
|
49
|
+
filter (current) current is ts_parameter
|
|
50
|
+
first
|
|
51
|
+
}
|
|
52
|
+
value parameter.parent.node
|
|
53
|
+
}
|
|
54
|
+
fn ts_usage_variable_scope_next(n) =
|
|
55
|
+
if n.parent is (ts_function, ts_class) && n is (ts_function.name, ts_class.name) then n.parent.node
|
|
56
|
+
else if n.parent is (ts_function, ts_arrow, ts_method, ts_static_block, ts_program) || n is ts_class_property.init then null
|
|
57
|
+
else n.parent.node
|
|
58
|
+
fn ts_usage_variable_scope(n) = {
|
|
59
|
+
value { value n; walk (current) ts_usage_variable_scope_next(current); last }.parent.node
|
|
60
|
+
}
|
|
61
|
+
fn ts_usage_in_loop(n) = {
|
|
62
|
+
value n.parent.node
|
|
63
|
+
walk (current) if current is (ts_function, ts_arrow, ts_method) then null else current.parent.node
|
|
64
|
+
any (current) current is ts_loop
|
|
65
|
+
}
|
|
66
|
+
fn ts_usage_unused_expression(n) = {
|
|
67
|
+
value terminal: {
|
|
68
|
+
value n
|
|
69
|
+
walk (current) {
|
|
70
|
+
value parent: ts_usage_parent(current)
|
|
71
|
+
value if parent is ts_sequence && unparenthesised_node(last(parent.expression.nodes)) == current then parent else null
|
|
72
|
+
}
|
|
73
|
+
last
|
|
74
|
+
}
|
|
75
|
+
value parent: ts_usage_parent(terminal)
|
|
76
|
+
value parent is ts_expression_statement || parent is ts_sequence
|
|
77
|
+
&& unparenthesised_node(last(parent.expression.nodes)) != terminal
|
|
78
|
+
}
|
|
79
|
+
fn ts_usage_statement(n) = if n is (ts_function, ts_class) then ts_declared_statement(n)
|
|
80
|
+
else n is ts_statement
|
|
81
|
+
fn ts_usage_storable_result(n, rhs) = {
|
|
82
|
+
value parent: ts_usage_parent(n)
|
|
83
|
+
value if !scoping_within(parent, rhs) then false
|
|
84
|
+
else if parent is ts_sequence && unparenthesised_node(last(parent.expression.nodes)) != n then false
|
|
85
|
+
else if parent is (ts_call, ts_new) then unparenthesised_node(parent.callee.node) != n
|
|
86
|
+
else if parent is (ts_assignment, ts_tagged_template, ts_yield) || ts_usage_statement(parent) then true
|
|
87
|
+
else null
|
|
88
|
+
}
|
|
89
|
+
fn ts_usage_storable_path(n, rhs) = {
|
|
90
|
+
value terminal: {
|
|
91
|
+
value n
|
|
92
|
+
walk (current) if ts_usage_storable_result(current, rhs) == null then ts_usage_parent(current) else null
|
|
93
|
+
last
|
|
94
|
+
}
|
|
95
|
+
value ts_usage_storable_result(terminal, rhs)
|
|
96
|
+
}
|
|
97
|
+
fn ts_usage_storable_function(n, rhs) = {
|
|
98
|
+
value function: {
|
|
99
|
+
value walk(n.parent.node, current => current.parent.node)
|
|
100
|
+
filter (current) current is (ts_function, ts_arrow, ts_method)
|
|
101
|
+
first
|
|
102
|
+
}
|
|
103
|
+
value scoping_within(function, rhs) && ts_usage_storable_path(function, rhs)
|
|
104
|
+
}
|
|
105
|
+
fn ts_usage_rhs(n, scope, previous) = {
|
|
106
|
+
value parent: ts_usage_parent(n)
|
|
107
|
+
value if scoping_within(n, previous) then previous
|
|
108
|
+
else if parent is ts_assignment && unparenthesised_node(parent.left.node) == n
|
|
109
|
+
&& ts_usage_unused_expression(parent) && ts_usage_variable_scope(n) == scope && !ts_usage_in_loop(n)
|
|
110
|
+
then parent.right.node else null
|
|
111
|
+
}
|
|
112
|
+
fn ts_usage_self_read(n, rhs) = {
|
|
113
|
+
value parent: ts_usage_parent(n)
|
|
114
|
+
value update: parent is ts_assignment && unparenthesised_node(parent.left.node) == n
|
|
115
|
+
&& !contains(["&&=", "||=", "??="], parent.operator) || parent is ts_update
|
|
116
|
+
value update && ts_usage_unused_expression(parent)
|
|
117
|
+
|| scoping_within(n, rhs) && !ts_usage_storable_function(n, rhs)
|
|
118
|
+
}
|
|
119
|
+
fn ts_usage_type_query(n) = {
|
|
120
|
+
value terminal: { value n; walk (current) if current.parent is (ts_qualified_name, ts_member) then current.parent.node else null; last }
|
|
121
|
+
value terminal.parent is ts_type_query
|
|
122
|
+
}
|
|
123
|
+
fn ts_usage_type_import(n) = n.parent is ts_import_specifier && n.parent.kind == "type"
|
|
124
|
+
|| n.parent is (ts_import_specifier, ts_import)
|
|
125
|
+
&& (if n.parent is ts_import_specifier then n.parent.parent.kind else n.parent.kind) == "type"
|
|
126
|
+
fn ts_usage_type_only(n, variable) = n.access == "type"
|
|
127
|
+
&& (variable || n.parent is ts_type_predicate || ts_usage_type_query(n))
|
|
128
|
+
fn ts_usage_initialized(n) = {
|
|
129
|
+
value n.scoping_definition_owners
|
|
130
|
+
any (current) current is ts_assignment_pattern.left
|
|
131
|
+
|| current is ts_pattern_property.key && current.parent.value is ts_assignment_pattern
|
|
132
|
+
|| current is ts_declarator.name && (current.parent.init != null
|
|
133
|
+
|| current.parent.parent is (ts_for_in.left, ts_for_of.left))
|
|
134
|
+
|| current is ts_parameter.name && current.parent.init != null
|
|
135
|
+
}
|
|
136
|
+
fn ts_usage_for_return(n) = {
|
|
137
|
+
value parent: ts_usage_parent(n)
|
|
138
|
+
value loop: if parent is ts_declarator then parent.parent.parent.node else parent
|
|
139
|
+
value body: loop.body.node
|
|
140
|
+
value statement: if body is ts_block then first(body.body.nodes) else body
|
|
141
|
+
value loop is (ts_for_in, ts_for_of) && statement is ts_return
|
|
142
|
+
}
|
|
143
|
+
fn ts_usage_own_nodes(sites, typed) = {
|
|
144
|
+
value sites
|
|
145
|
+
flat_map (site) {
|
|
146
|
+
value parent: site.parent.node
|
|
147
|
+
value init: unparenthesised_node(parent.init.node)
|
|
148
|
+
value if site is ts_function.name then [parent]
|
|
149
|
+
else if site is ts_declarator.name && init is (ts_function, ts_arrow) then [init]
|
|
150
|
+
else if typed && parent is (ts_interface, ts_type_alias, ts_namespace, ts_enum) then [parent]
|
|
151
|
+
else []
|
|
152
|
+
}
|
|
153
|
+
}
|
|
154
|
+
fn ts_usage_exports_override(body) = any([] body.body.nodes, statement => statement is ts_export_assignment
|
|
155
|
+
|| statement is ts_export && (if statement.kind == "default"
|
|
156
|
+
then unparenthesised_node(statement.expression.node) is ts_identifier else statement.declaration == null))
|
|
157
|
+
fn ts_usage_ambient(n, declaration_file) = {
|
|
158
|
+
value site: ts_usage_site(n)
|
|
159
|
+
value outer: if site.parent is ts_export then site.parent.node else site
|
|
160
|
+
value container: outer.parent.node
|
|
161
|
+
value namespace: container.parent.node
|
|
162
|
+
value if site not (ts_interface, ts_type_alias, ts_class, ts_function, ts_enum, ts_namespace, ts_variable_declaration)
|
|
163
|
+
|| ts_usage_exports_override(container) then false
|
|
164
|
+
else if container is ts_program then declaration_file
|
|
165
|
+
else namespace is ts_namespace && (declaration_file || {
|
|
166
|
+
value walk(namespace, current => current.parent.node)
|
|
167
|
+
any (current) current is ts_namespace && contains([] current.modifier, "declare")
|
|
168
|
+
})
|
|
169
|
+
}
|
|
170
|
+
fn ts_usage_marked(n, typed, declaration_file) = typed && {
|
|
171
|
+
value site: ts_usage_site(n)
|
|
172
|
+
value site is ts_parameter && {
|
|
173
|
+
value function: ts_usage_function(n)
|
|
174
|
+
value signature: function is (ts_function_type, ts_call_signature, ts_method_signature)
|
|
175
|
+
|| function is (ts_function, ts_method) && function.body == null
|
|
176
|
+
value signature || count(site.modifier.nodes) > 0 || function.kind == "set"
|
|
177
|
+
}
|
|
178
|
+
|| site is ts_type_parameter && site.parent is ts_mapped_type
|
|
179
|
+
|| site is ts_namespace && n.text == "global"
|
|
180
|
+
|| ts_usage_ambient(n, declaration_file)
|
|
181
|
+
|| contains(n.scoping_program.ts_usage_return_bindings, n.ts_usage_binding.node)
|
|
182
|
+
}
|
|
183
|
+
fn ts_usage_before_parameter(n, typed, declaration_file) = {
|
|
184
|
+
value parameter: n.parent.node
|
|
185
|
+
value function: parameter.parent.node
|
|
186
|
+
value if n not ts_parameter.name || parameter.init != null || count(parameter.modifier.nodes) > 0
|
|
187
|
+
|| function not (ts_function, ts_arrow, ts_method) then false else {
|
|
188
|
+
value names: {
|
|
189
|
+
value [] function.parameter.nodes
|
|
190
|
+
flat_map (parameter) {
|
|
191
|
+
value name: parameter.name.node
|
|
192
|
+
value if name is ts_identifier then [name] else {
|
|
193
|
+
value [name]
|
|
194
|
+
walk (current) current.children.nodes
|
|
195
|
+
filter (identifier) identifier is ts_identifier
|
|
196
|
+
&& name_role_classes(identifier, "declaration") != null && ts_usage_site(identifier) == parameter
|
|
197
|
+
sort_by (identifier) identifier.offset
|
|
198
|
+
}
|
|
199
|
+
}
|
|
200
|
+
}
|
|
201
|
+
value index: index_of(names, n)
|
|
202
|
+
value if index < 0 then false else {
|
|
203
|
+
value names
|
|
204
|
+
slice (index + 1)
|
|
205
|
+
any (later) {
|
|
206
|
+
value binding: name_binding(later)
|
|
207
|
+
value binding != null && (count(binding.references) > 0
|
|
208
|
+
|| any(binding.declarations, site => ts_usage_initialized(site) || ts_usage_marked(site, typed, declaration_file)))
|
|
209
|
+
}
|
|
210
|
+
}
|
|
211
|
+
}
|
|
212
|
+
}
|
|
213
|
+
fn ts_usage_rest_sibling(n) = {
|
|
214
|
+
value parent: n.parent.node
|
|
215
|
+
value if parent not (ts_pattern_property, ts_property)
|
|
216
|
+
|| n == parent.key.node && parent.value is ts_assignment_pattern then false
|
|
217
|
+
else if parent is ts_pattern_property then parent.parent.rest != null
|
|
218
|
+
else parent.parent is ts_object && last(parent.parent.property.nodes) is ts_spread
|
|
219
|
+
}
|
|
220
|
+
fn ts_usage_global(binding, program) = ts_source_type(program) == "script"
|
|
221
|
+
&& binding.scope.id == last(program.scoping_lexical_scopes).id
|
|
222
|
+
fn ts_usage_used(binding, sites, references, typed, variable, value_binding, declaration_file) = {
|
|
223
|
+
value declaration: first(sites)
|
|
224
|
+
value program: declaration.scoping_program
|
|
225
|
+
value global: ts_usage_global(binding, program)
|
|
226
|
+
value exported_comment: global && contains(ts_exported_names(program), declaration.text)
|
|
227
|
+
value jsx: typed && ts_usage_jsx_used(binding, program)
|
|
228
|
+
value exported: typed && any(sites, site => {
|
|
229
|
+
value owner: ts_usage_site(site)
|
|
230
|
+
value !(value_binding && owner is (ts_interface, ts_type_alias)) && owner.parent is ts_export
|
|
231
|
+
})
|
|
232
|
+
value marked: any(sites, site => ts_usage_marked(site, typed, declaration_file))
|
|
233
|
+
value if marked || jsx || exported_comment || exported then true else {
|
|
234
|
+
value own: ts_usage_own_nodes(sites, typed)
|
|
235
|
+
value scope: ts_usage_variable_scope(declaration)
|
|
236
|
+
value imported_type: all(sites, site => ts_usage_type_import(site))
|
|
237
|
+
value state: {
|
|
238
|
+
value references
|
|
239
|
+
fold ({ used: false, rhs: null }) (state, reference)
|
|
240
|
+
if state.used then state else {
|
|
241
|
+
value n: reference.node
|
|
242
|
+
value self_read: reference.read && ts_usage_self_read(n, state.rhs)
|
|
243
|
+
value rhs: ts_usage_rhs(n, scope, state.rhs)
|
|
244
|
+
value type_only: typed && !imported_type && ts_usage_type_only(n, variable)
|
|
245
|
+
value used: !typed && ts_usage_for_return(n) || reference.read && !self_read && !type_only
|
|
246
|
+
&& !any(own, owner => scoping_within(n, owner))
|
|
247
|
+
value { used: used, rhs: rhs }
|
|
248
|
+
}
|
|
249
|
+
}
|
|
250
|
+
value state.used
|
|
251
|
+
}
|
|
252
|
+
}
|
|
253
|
+
in ts_identifier let ts_usage_binding name_binding(node)
|
|
254
|
+
in ts_program let ts_usage_typed
|
|
255
|
+
any([".ts", ".tsx", ".mts", ".cts"], extension => ends_with(file, extension))
|
|
256
|
+
in ts_program let ts_usage_declaration_file ts_usage_typed && contains(last(split(file, "/")), ".d.")
|
|
257
|
+
in ts_node let ts_usage_typed scoping_program.ts_usage_typed
|
|
258
|
+
in ts_node let ts_usage_declaration_file scoping_program.ts_usage_declaration_file
|
|
259
|
+
fn ts_usage_reference(n) = {
|
|
260
|
+
node: n,
|
|
261
|
+
read: contains(["read", "read_write", "type"], n.access),
|
|
262
|
+
write: contains(["write", "read_write"], n.access)
|
|
263
|
+
}
|
|
264
|
+
fn ts_usage_summary(n) = if !n.scoping_lexical_declaration || n.parent is ts_qualified_name
|
|
265
|
+
|| n is (ts_function.name, ts_class.name) && !ts_declared_statement(n.parent.node) then null else {
|
|
266
|
+
value binding: n.ts_usage_binding
|
|
267
|
+
value if binding == null || binding.node != n then null else {
|
|
268
|
+
value sites: binding.declarations
|
|
269
|
+
value site: ts_usage_site(n)
|
|
270
|
+
value typed: n.ts_usage_typed
|
|
271
|
+
value declaration_file: n.ts_usage_declaration_file
|
|
272
|
+
value real: map(binding.references, reference => ts_usage_reference(reference))
|
|
273
|
+
value initial: {
|
|
274
|
+
value sites
|
|
275
|
+
filter (site) ts_usage_initialized(site)
|
|
276
|
+
map (site) { node: site, read: false, write: true }
|
|
277
|
+
}
|
|
278
|
+
value references: { value real initial; sort_by (reference) reference.node.offset }
|
|
279
|
+
value classes: { value sites; filter (site) site is ts_class.name; map (site) site.parent.node }
|
|
280
|
+
value own: filter(references, reference => !any(classes, owner => scoping_within(reference.node, owner)))
|
|
281
|
+
value variable: any(sites, site => ts_usage_site(site) is ts_variable_declaration)
|
|
282
|
+
value value_binding: any(sites, site => ts_usage_site(site) not (ts_interface, ts_type_alias))
|
|
283
|
+
value used: ts_usage_used(binding, sites, own, typed, variable, value_binding, declaration_file)
|
|
284
|
+
value { sites: sites, site: site, typed: typed, declaration_file: declaration_file,
|
|
285
|
+
classes: classes, own: own, variable: variable, used: used }
|
|
286
|
+
}
|
|
287
|
+
}
|
|
288
|
+
in ts_identifier let ts_usage_summary ts_usage_summary(node)
|
|
289
|
+
fn ts_usage_context(n) = {
|
|
290
|
+
value summary: n.ts_usage_summary
|
|
291
|
+
value if summary == null then null else {
|
|
292
|
+
value sites: summary.sites
|
|
293
|
+
value site: summary.site
|
|
294
|
+
value typed: summary.typed
|
|
295
|
+
value declaration_file: summary.declaration_file
|
|
296
|
+
value own: summary.own
|
|
297
|
+
value classes: summary.classes
|
|
298
|
+
value used: summary.used
|
|
299
|
+
value only_type: typed && any(own, reference => ts_usage_type_only(reference.node, summary.variable))
|
|
300
|
+
value scope: ts_usage_variable_scope(n)
|
|
301
|
+
value write: find_last(own, reference => reference.write && ts_usage_variable_scope(reference.node) == scope)
|
|
302
|
+
value report_site: write.node ?? n
|
|
303
|
+
value def: if site is ts_parameter then "parameter" else if site is ts_try then "catch" else "variable"
|
|
304
|
+
value {
|
|
305
|
+
used: used,
|
|
306
|
+
exported: !typed && any(sites, site => ts_usage_site(site).parent is ts_export),
|
|
307
|
+
silent: only_type && site is (ts_import, ts_import_specifier, ts_import_equals),
|
|
308
|
+
def: def,
|
|
309
|
+
array_element: n.parent is ts_array_pattern,
|
|
310
|
+
array_target: any(own, reference => reference.write && reference.node.parent is ts_array),
|
|
311
|
+
setter: def == "parameter" && ts_usage_function(n).kind == "set",
|
|
312
|
+
before_used_param: !used && def == "parameter" && ts_usage_before_parameter(n, typed, declaration_file),
|
|
313
|
+
rest_sibling: any(sites, site => ts_usage_rest_sibling(site))
|
|
314
|
+
|| any(own, reference => ts_usage_rest_sibling(reference.node)),
|
|
315
|
+
static_block: any(classes, owner => any(owner.member.nodes, member => member is ts_static_block)),
|
|
316
|
+
using: any(sites, site => contains(["using", "await using"], site.scoping_site_kind)),
|
|
317
|
+
global: ts_usage_global(n.ts_usage_binding, n.scoping_program),
|
|
318
|
+
action: if any(own, reference => reference.write) then "assigned a value" else "defined",
|
|
319
|
+
only_type: only_type,
|
|
320
|
+
report_site: report_site,
|
|
321
|
+
ignored_report_site: if typed then report_site else n
|
|
322
|
+
}
|
|
323
|
+
}
|
|
324
|
+
}
|
|
325
|
+
in ts_identifier let unused_var ts_usage_context(node)
|
|
326
|
+
fn ts_usage_ignored(n, pattern) = {
|
|
327
|
+
value policy: if type_of(n.no_unused_vars_ignored) == "null" then pattern else n.no_unused_vars_ignored
|
|
328
|
+
value if type_of(policy) == "bool" then policy
|
|
329
|
+
else type_of(policy) == "str" && policy != "" && re_test(n.text, policy)
|
|
330
|
+
}
|
|
331
|
+
fn ts_usage_import_name(item) = if item is ts_import_specifier then item.local.node ?? item.imported.node else item
|
|
332
|
+
fn ts_usage_import_removable(n, pattern) = {
|
|
333
|
+
value u: n.unused_var
|
|
334
|
+
value u != null && u.used == false && !u.exported && !u.silent
|
|
335
|
+
&& n.no_unused_vars_checked && !ts_usage_ignored(n, pattern)
|
|
336
|
+
}
|
|
337
|
+
fn ts_usage_import_line(source, statement) = {
|
|
338
|
+
value start: position(statement.offset).js_line_start
|
|
339
|
+
value prefix: byte_slice(source, start, statement.offset)
|
|
340
|
+
value tail: re_find(byte_slice(source, statement.end_offset), /^[ \t]*(?:\r\n|[\r\n\u{2028}\u{2029}]|$)/)
|
|
341
|
+
value if re_test(prefix, /^[ \t]*$/) && tail != null
|
|
342
|
+
then { start: start, end: statement.end_offset + byte_len(tail) }
|
|
343
|
+
else statement
|
|
344
|
+
}
|
|
345
|
+
fn ts_usage_import_removal(source, n, pattern) = {
|
|
346
|
+
value item: if n.parent is ts_import_specifier then n.parent.node else n
|
|
347
|
+
value statement: item.parent.node
|
|
348
|
+
value if statement not ts_import then null else {
|
|
349
|
+
value named: statement.specifier.nodes
|
|
350
|
+
value bindings: compact([statement.default_import.node, statement.namespace.node]
|
|
351
|
+
map(named, specifier => ts_usage_import_name(specifier)))
|
|
352
|
+
value whole: all(bindings, binding => ts_usage_import_removable(binding, pattern))
|
|
353
|
+
value all_named: count(named) > 0
|
|
354
|
+
&& all(named, specifier => ts_usage_import_removable(ts_usage_import_name(specifier), pattern))
|
|
355
|
+
value if whole then ts_usage_import_line(source, statement)
|
|
356
|
+
else if item is ts_import_specifier && all_named && statement.default_import != null
|
|
357
|
+
then { start: statement.default_import.token_neighbours.after.start, end: statement.import_named_close.end }
|
|
358
|
+
else if item is ts_import_specifier then {
|
|
359
|
+
value before: item.token_neighbours.before
|
|
360
|
+
value after: item.token_neighbours.after
|
|
361
|
+
value { start: if before.text == "," then before.start else item.offset,
|
|
362
|
+
end: if before.text != "," && after.text == "," then after.end else item.end_offset }
|
|
363
|
+
}
|
|
364
|
+
else if item == statement.namespace.node && statement.default_import != null
|
|
365
|
+
then { start: statement.default_import.token_neighbours.after.start, end: item.end_offset }
|
|
366
|
+
else if item == statement.default_import.node && item.token_neighbours.after.text == ","
|
|
367
|
+
then { start: item.offset, end: item.token_neighbours.after.end }
|
|
368
|
+
else null
|
|
369
|
+
}
|
|
370
|
+
}
|
|
371
|
+
in ts_program let unused_globals {
|
|
372
|
+
value program: node
|
|
373
|
+
value script: ts_source_type(program) == "script"
|
|
374
|
+
value root: last(scoping_lexical_scopes)
|
|
375
|
+
value references: descendants(ts_identifier)
|
|
376
|
+
value read: {
|
|
377
|
+
value references
|
|
378
|
+
filter (reference) reference.global != null && reference.access != "write"
|
|
379
|
+
map (reference) ts_module_name(reference)
|
|
380
|
+
}
|
|
381
|
+
value top: {
|
|
382
|
+
value references
|
|
383
|
+
filter (declaration) script && declaration.ts_usage_binding.scope.id == root.id
|
|
384
|
+
map (declaration) ts_module_name(declaration)
|
|
385
|
+
}
|
|
386
|
+
value ts_global_mentions(program)
|
|
387
|
+
filter (mention) ts_global_setting(program, mention.name) != "off"
|
|
388
|
+
&& !contains(read, mention.name) && !contains(top, mention.name)
|
|
389
|
+
unique_by (mention) mention.name
|
|
390
|
+
map (mention) { name: mention.name, offset: mention.offset }
|
|
391
|
+
}
|
|
392
|
+
|
|
393
|
+
}
|