react_auditor/rules/react/
prefer_function_components.rs1use oxc_ast::ast::Program;
2use oxc_ast_visit::Visit;
3use oxc_semantic::Semantic;
4
5use crate::rules::{Fix, Rule, RuleFinding, RuleMeta, Severity};
6
7pub struct PreferFunctionComponents;
8
9const RULE_META: RuleMeta = RuleMeta {
10 id: "prefer-function-components",
11 default_severity: Severity::Warning,
12 category: "react",
13 description: "Prefer function components over class components",
14};
15
16impl Rule for PreferFunctionComponents {
17 fn meta(&self) -> &RuleMeta {
18 &RULE_META
19 }
20
21 fn run(&self, program: &Program, _semantic: &Semantic, source_text: &str) -> Vec<RuleFinding> {
22 let mut collector = ClassComponentCollector {
23 findings: Vec::new(),
24 source: source_text,
25 };
26 collector.visit_program(program);
27 collector.findings
28 }
29
30 fn has_fix(&self) -> bool {
31 true
32 }
33
34 fn fix(&self, finding: &RuleFinding, source_text: &str) -> Option<Fix> {
35 let class_name_offset =
36 crate::rules::line_col_to_offset(source_text, finding.line, finding.column)?;
37
38 let before = &source_text[..class_name_offset];
39 let class_keyword_start = before.rfind("class")?;
40 let after_name = &source_text[class_name_offset..];
41
42 let body_open = after_name.find('{')?;
43 let body_start = class_name_offset + body_open + 1;
44
45 let body_end = find_matching_brace(source_text, body_start - 1)?;
46
47 let class_body = &source_text[body_start..body_end];
48
49 let render_body = extract_render_body(source_text, body_start, body_end)?;
50
51 let state_init = extract_state_initializer(class_body);
52
53 let uses_props = class_body.contains("this.props");
54 let has_lifecycle = has_lifecycle_method(class_body);
55
56 if has_lifecycle {
57 return None;
58 }
59
60 let props_param = if uses_props { "props" } else { "_props" };
61
62 let mut fn_body = String::new();
63
64 if let Some((_state_vars, state_values)) = state_init {
65 let state_var_count = count_state_vars(&state_values);
66 if state_var_count == 0 {
67 fn_body.push_str(" // TODO: migrate state manually\n");
68 } else {
69 let var_names: Vec<String> = (0..state_var_count)
70 .map(|i| {
71 format!(
72 "state{}",
73 if i == 0 { String::new() } else { i.to_string() }
74 )
75 })
76 .collect();
77 let setter_names: Vec<String> = (0..state_var_count)
78 .map(|i| {
79 format!(
80 "setState{}",
81 if i == 0 { String::new() } else { i.to_string() }
82 )
83 })
84 .collect();
85 fn_body.push_str(&format!(
86 " const [{}] = useState({});\n\n",
87 var_names
88 .iter()
89 .zip(setter_names.iter())
90 .map(|(v, s)| format!("{v}, {s}"))
91 .collect::<Vec<_>>()
92 .join(", "),
93 state_values,
94 ));
95 }
96 }
97
98 fn_body.push_str(&render_body);
99
100 let class_name = find_class_name(after_name)?;
101
102 let result = format!("function {class_name}({props_param}) {{\n{fn_body}}}");
103
104 Some(Fix {
105 start: class_keyword_start,
106 end: body_end + 1,
107 replacement: result,
108 })
109 }
110}
111
112fn find_matching_brace(source: &str, open_pos: usize) -> Option<usize> {
113 let bytes = source.as_bytes();
114 if open_pos >= bytes.len() || bytes[open_pos] != b'{' {
115 return None;
116 }
117 let mut depth = 1u32;
118 let mut i = open_pos + 1;
119 while i < bytes.len() {
120 if bytes[i] == b'{' {
121 depth += 1;
122 } else if bytes[i] == b'}' {
123 depth -= 1;
124 if depth == 0 {
125 return Some(i);
126 }
127 }
128 i += 1;
129 }
130 None
131}
132
133fn extract_render_body(source: &str, body_start: usize, body_end: usize) -> Option<String> {
134 let body = &source[body_start..body_end];
135 let render_pos = body.find("render")?;
136 let after_render = &body[render_pos..];
137 let paren_start = after_render.find('(')?;
138 let paren_end = after_render[paren_start..].find(')')? + paren_start;
139 let after_paren = &after_render[paren_end..];
140 let brace_start = after_paren.find('{')?;
141 let render_brace_start = body_start + render_pos + paren_end + brace_start;
142 let render_brace_end = find_matching_brace(source, render_brace_start + 1)?;
143
144 let render_content = &source[render_brace_start + 1..render_brace_end];
145 let trimmed = render_content.trim();
146
147 let mut body = String::with_capacity(trimmed.len() + 32);
148 for line in trimmed.lines() {
149 body.push_str(" ");
150 body.push_str(line.trim());
151 body.push('\n');
152 }
153
154 Some(body)
155}
156
157fn extract_state_initializer(class_body: &str) -> Option<(Vec<String>, String)> {
158 let constructor_pos = class_body.find("constructor")?;
159 let after_ctor = &class_body[constructor_pos..];
160 let brace_start = after_ctor.find('{')?;
161 let after_brace = &after_ctor[brace_start + 1..];
162 let this_state_pos = after_brace.find("this.state = ")?;
163 let assign_start = this_state_pos + "this.state = ".len();
164 let remaining = &after_brace[assign_start..];
165 let obj_brace = remaining.find('{')?;
166 let obj_end = find_matching_brace_inner(remaining, obj_brace)?;
167
168 let state_obj = &remaining[..=obj_end];
169 Some((Vec::new(), state_obj.to_string()))
170}
171
172fn find_matching_brace_inner(s: &str, open_pos: usize) -> Option<usize> {
173 let bytes = s.as_bytes();
174 if open_pos >= bytes.len() || bytes[open_pos] != b'{' {
175 return None;
176 }
177 let mut depth = 1u32;
178 let mut i = open_pos + 1;
179 while i < bytes.len() {
180 if bytes[i] == b'{' {
181 depth += 1;
182 } else if bytes[i] == b'}' {
183 depth -= 1;
184 if depth == 0 {
185 return Some(i);
186 }
187 }
188 i += 1;
189 }
190 None
191}
192
193fn count_state_vars(state_values: &str) -> usize {
194 let mut count = 0;
195 let mut in_string = false;
196 let mut in_template = false;
197 let bytes = state_values.as_bytes();
198 let mut i = 0;
199 while i < bytes.len() {
200 match bytes[i] {
201 b'"' | b'\'' if !in_template => in_string = !in_string,
202 b'`' if !in_string => in_template = !in_template,
203 b':' if !in_string && !in_template => count += 1,
204 _ => {}
205 }
206 i += 1;
207 }
208 count
209}
210
211fn find_class_name(after_name: &str) -> Option<String> {
212 let trimmed = after_name.trim_start();
213 let end = trimmed.find(|c: char| c.is_whitespace() || c == '{' || c == '<')?;
214 Some(trimmed[..end].to_string())
215}
216
217fn has_lifecycle_method(class_body: &str) -> bool {
218 let lifecycle_methods = [
219 "componentDidMount",
220 "componentDidUpdate",
221 "componentWillUnmount",
222 "shouldComponentUpdate",
223 "getDerivedStateFromProps",
224 "getSnapshotBeforeUpdate",
225 "componentDidCatch",
226 "UNSAFE_componentWillMount",
227 "UNSAFE_componentWillReceiveProps",
228 "UNSAFE_componentWillUpdate",
229 ];
230 lifecycle_methods.iter().any(|m| class_body.contains(m))
231}
232
233struct ClassComponentCollector<'a> {
234 findings: Vec<RuleFinding>,
235 source: &'a str,
236}
237
238impl<'a> Visit<'a> for ClassComponentCollector<'a> {
239 fn visit_class(&mut self, class: &oxc_ast::ast::Class<'a>) {
240 let extends_react = class.super_class.as_ref().is_some_and(|expr| {
241 if let oxc_ast::ast::Expression::Identifier(ident) = expr {
242 let name = ident.name.as_str();
243 name == "Component" || name == "PureComponent"
244 } else if let Some(member) = expr.as_member_expression() {
245 member
246 .static_property_name()
247 .is_some_and(|n| n == "Component" || n == "PureComponent")
248 } else {
249 false
250 }
251 });
252
253 if extends_react && let Some(id) = &class.id {
254 let start = id.span.start as usize;
255 let line = self.source[..start].lines().count().max(1);
256 let col = start - self.source[..start].rfind('\n').map(|i| i + 1).unwrap_or(0);
257 self.findings.push(RuleFinding {
258 line,
259 column: col + 1,
260 message: format!(
261 "`{}` extends Component — prefer a function component",
262 id.name
263 ),
264 });
265 }
266 }
267}