Skip to content

Commit ed9dae7

Browse files
me-crme-cr
committed
Refactor LL6 rule: handle function calls broken after opening paren
1 parent 698813a commit ed9dae7

File tree

11 files changed

+323
-80
lines changed

11 files changed

+323
-80
lines changed

‎example_files/example_lint_cfg.json‎

Lines changed: 2 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -13,5 +13,6 @@
1313
"indent_paren_expr": {},
1414
"indent_switch_case": {},
1515
"indent_empty_loop": {},
16-
"indent_continuation_line": {}
16+
"indent_continuation_line": {},
17+
"func_call_break_on_open_paren": {}
1718
}

‎src/analysis/parsing/expression.rs‎

Lines changed: 7 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -25,7 +25,7 @@ use crate::lint::{DMLStyleError,
2525
CurrentRules},
2626
AuxParams};
2727
use crate::lint::rules::indentation::IndentParenExprArgs;
28-
use crate::lint::rules::linebreaking::FuncCallBreakOnOpeningParenArgs;
28+
use crate::lint::rules::linebreaking::FuncCallBreakOnOpenParenArgs;
2929

3030
#[derive(Debug, Clone, PartialEq)]
3131
pub struct UnaryExpressionContent {
@@ -170,6 +170,8 @@ impl TreeElement for ParenExpressionContent {
170170
}
171171
fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {
172172
rules.indent_paren_expr.check(acc, IndentParenExprArgs::from_paren_expression(self));
173+
rules.func_call_break_on_open_paren.check(acc,
174+
FuncCallBreakOnOpenParenArgs::from_paren_expression(self, _aux.depth));
173175
}
174176
}
175177

@@ -220,8 +222,8 @@ impl TreeElement for FunctionCallContent {
220222
rules.nsp_inparen.check(acc, NspInparenArgs::from_function_call(self));
221223
rules.sp_punct.check(acc, SpPunctArgs::from_function_call(self));
222224
rules.indent_paren_expr.check(acc, IndentParenExprArgs::from_function_call(self));
223-
rules.func_call_break_on_opening_paren
224-
.check(acc, FuncCallBreakOnOpeningParenArgs::from_function_call(self, aux.depth));
225+
rules.func_call_break_on_open_paren
226+
.check(acc, FuncCallBreakOnOpenParenArgs::from_function_call(self, aux.depth));
225227
}
226228
}
227229

@@ -337,6 +339,8 @@ impl TreeElement for CastContent {
337339
}
338340
fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {
339341
rules.indent_paren_expr.check(acc, IndentParenExprArgs::from_cast(self));
342+
rules.func_call_break_on_open_paren
343+
.check(acc, FuncCallBreakOnOpenParenArgs::from_cast(self, _aux.depth));
340344
}
341345
}
342346

‎src/analysis/parsing/structure.rs‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -16,6 +16,7 @@ use crate::analysis::parsing::parser::{doesnt_understand_tokens,
1616
FileParser, Parse, ParseContext,
1717
FileInfo};
1818
use crate::analysis::LocalDMLError;
19+
use crate::lint::rules::linebreaking::FuncCallBreakOnOpenParenArgs;
1920
use crate::lint::rules::spacing::{SpBracesArgs,
2021
NspInparenArgs,
2122
NspFunparArgs,
@@ -240,6 +241,7 @@ impl TreeElement for MethodContent {
240241
rules.nsp_inparen.check(acc, NspInparenArgs::from_method(self));
241242
rules.sp_punct.check(acc, SpPunctArgs::from_method(self));
242243
rules.indent_paren_expr.check(acc, IndentParenExprArgs::from_method(self));
244+
rules.func_call_break_on_open_paren.check(acc, FuncCallBreakOnOpenParenArgs::from_method(self, _aux.depth));
243245
}
244246
}
245247

‎src/lint/mod.rs‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,7 @@ use std::fmt;
22
use std::fs;
33
use std::path::{Path, PathBuf};
44
use log::{debug, error, trace};
5-
use rules::linebreaking::FuncCallBreakOnOpeningParenOptions;
5+
use rules::linebreaking::FuncCallBreakOnOpenParenOptions;
66
use serde::{Deserialize, Serialize};
77
use rules::{instantiate_rules, CurrentRules, RuleType};
88
use rules::{spacing::{SpBraceOptions, SpPunctOptions, NspFunparOptions,
@@ -77,7 +77,7 @@ pub struct LintCfg {
7777
#[serde(default)]
7878
pub indent_continuation_line: Option<IndentContinuationLineOptions>,
7979
#[serde(default)]
80-
pub func_call_break_on_opening_paren: Option<FuncCallBreakOnOpeningParenOptions>,
80+
pub func_call_break_on_open_paren: Option<FuncCallBreakOnOpenParenOptions>,
8181
}
8282

8383
impl Default for LintCfg {
@@ -98,7 +98,7 @@ impl Default for LintCfg {
9898
indent_switch_case: Some(IndentSwitchCaseOptions{indentation_spaces: INDENTATION_LEVEL_DEFAULT}),
9999
indent_empty_loop: Some(IndentEmptyLoopOptions{indentation_spaces: INDENTATION_LEVEL_DEFAULT}),
100100
indent_continuation_line: Some(IndentContinuationLineOptions{indentation_spaces: INDENTATION_LEVEL_DEFAULT}),
101-
func_call_break_on_opening_paren: Some(FuncCallBreakOnOpeningParenOptions{}),
101+
func_call_break_on_open_paren: Some(FuncCallBreakOnOpenParenOptions{indentation_spaces: INDENTATION_LEVEL_DEFAULT}),
102102
}
103103
}
104104
}

‎src/lint/rules/indentation.rs‎

Lines changed: 6 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -505,9 +505,14 @@ impl IndentParenExprRule {
505505
args: Option<IndentParenExprArgs>) {
506506
if !self.enabled { return; }
507507
let Some(args) = args else { return; };
508+
if args.members_ranges.is_empty() { return; }
508509
let expected_line_start = args.lparen.col_start.0 + 1;
509510
let mut last_row = args.lparen.row_start.0;
510-
511+
if last_row != args.members_ranges.first().unwrap().row_start.0 {
512+
// If the first member is not on the same line as the lparen,
513+
// then it is not a continuation line, so we do not check it.
514+
return;
515+
}
511516
for member_range in args.members_ranges {
512517
if member_range.row_start.0 != last_row {
513518
last_row = member_range.row_start.0;

‎src/lint/rules/linebreaking.rs‎

Lines changed: 130 additions & 49 deletions
Original file line numberDiff line numberDiff line change
@@ -1,37 +1,118 @@
11
use serde::{Deserialize, Serialize};
22
use crate::analysis::parsing::lexer::TokenKind;
3-
use crate::analysis::parsing::tree::{ZeroRange, TreeElement};
4-
use crate::analysis::parsing::{expression::{CastContent, FunctionCallContent}};
5-
use crate::lint::{DMLStyleError, LintCfg, RuleType};
6-
use crate::lint::rules::indentation::IndentParenExprArgs;
3+
use crate::analysis::parsing::parser::Token;
4+
use crate::analysis::parsing::structure::MethodContent;
5+
use crate::analysis::parsing::tree::{TreeElement, TreeElementTokenIterator, ZeroRange};
6+
use crate::analysis::parsing::expression::{CastContent, FunctionCallContent, ParenExpressionContent};
7+
use crate::lint::{DMLStyleError, RuleType};
8+
use super::indentation::IndentParenExprArgs;
79
use super::Rule;
810

9-
pub struct FuncCallBreakOnOpeningParen {
11+
pub const INDENTATION_LEVEL_DEFAULT: u32 = 4;
12+
13+
fn default_indentation_spaces() -> u32 {
14+
INDENTATION_LEVEL_DEFAULT
15+
}
16+
17+
pub struct FuncCallBreakOnOpenParenRule {
1018
pub enabled: bool,
19+
indentation_spaces: u32
1120
}
1221

13-
pub struct FuncCallBreakOnOpeningParenArgs {
14-
pub member_ranges: Vec<ZeroRange>,
22+
pub struct FuncCallBreakOnOpenParenArgs {
23+
pub members_ranges: Vec<ZeroRange>,
1524
pub expected_depth: u32,
25+
pub lparen: ZeroRange,
1626
}
1727

1828
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
19-
pub struct FuncCallBreakOnOpeningParenOptions{}
29+
pub struct FuncCallBreakOnOpenParenOptions{
30+
#[serde(default = "default_indentation_spaces")]
31+
pub indentation_spaces: u32,
32+
}
33+
34+
impl Rule for FuncCallBreakOnOpenParenRule {
35+
fn name() -> &'static str {
36+
"FUNC_CALL_BREAK_ON_OPEN_PAREN"
37+
}
38+
fn description() -> &'static str {
39+
"Function or method calls broken right after opening parenthesis should
40+
indent continuation lines one more level."
41+
}
42+
fn get_rule_type() -> RuleType {
43+
RuleType::LL6
44+
}
45+
}
46+
47+
impl FuncCallBreakOnOpenParenRule {
48+
pub fn from_options(options: &Option<FuncCallBreakOnOpenParenOptions>) -> FuncCallBreakOnOpenParenRule {
49+
match options {
50+
Some(options) => FuncCallBreakOnOpenParenRule {
51+
enabled: true,
52+
indentation_spaces: options.indentation_spaces
53+
},
54+
None => FuncCallBreakOnOpenParenRule {
55+
enabled: false,
56+
indentation_spaces: 0
57+
}
58+
}
59+
}
2060

21-
// pub struct FunctionCallContent {
22-
// pub fun: Expression,
23-
// pub lparen: LeafToken,
24-
// pub arguments: Vec<(SingleInitializer, Option<LeafToken>)>,
25-
// pub rparen: LeafToken,
26-
// }
61+
pub fn check(&self, acc: &mut Vec<DMLStyleError>, args: Option<FuncCallBreakOnOpenParenArgs>) {
62+
if !self.enabled { return; }
63+
let Some(args) = args else { return; };
64+
if args.members_ranges.is_empty() { return; }
65+
let expected_line_start = self.indentation_spaces * (args.expected_depth + 1);
66+
let mut last_row = args.lparen.row_start.0;
67+
if last_row == args.members_ranges.first().unwrap().row_start.0 {
68+
// If the first member is on the same line as the lparen, we don't
69+
// need to check it.
70+
return;
71+
}
72+
for member_range in args.members_ranges {
73+
if member_range.row_start.0 != last_row {
74+
last_row = member_range.row_start.0;
75+
if member_range.col_start.0 != expected_line_start {
76+
acc.push(self.create_err(member_range));
77+
}
78+
}
79+
}
80+
}
81+
}
2782

28-
impl FuncCallBreakOnOpeningParenArgs {
29-
pub fn from_function_call(node: &FunctionCallContent, depth: u32) -> Option<FuncCallBreakOnOpeningParenArgs> {
83+
impl FuncCallBreakOnOpenParenArgs {
84+
pub fn filter_out_parenthesized_tokens(expression_tokens: TreeElementTokenIterator) -> Vec<Token> {
85+
let mut token_list: Vec<Token> = vec![];
86+
let mut paren_depth = 0;
87+
// paren_depth is used to identify nested
88+
// parenthesized expressions within other expressions
89+
// and avoid double checking this type, given
90+
// ParenExpressionContent already checks indent_paren_expr on its own
91+
for token in expression_tokens {
92+
match token.kind {
93+
TokenKind::LParen => {
94+
if paren_depth == 0 { token_list.push(token); }
95+
paren_depth += 1;
96+
},
97+
TokenKind::RParen => {
98+
paren_depth-=1;
99+
},
100+
TokenKind::LBrace => {
101+
break;
102+
},
103+
_ => {
104+
if paren_depth == 0 { token_list.push(token); }
105+
}
106+
}
107+
}
108+
token_list
109+
}
110+
pub fn from_function_call(node: &FunctionCallContent, depth: u32) -> Option<FuncCallBreakOnOpenParenArgs> {
30111
let mut filtered_member_ranges: Vec<ZeroRange> = vec![];
31112
for (arg, _comma) in node.arguments.iter() {
32113
filtered_member_ranges.extend(
33-
IndentParenExprArgs::filter_out_parenthesized_tokens(arg.tokens())
34-
.iter().filter(|t| t.kind != TokenKind::RParen).map(|t| t.range)
114+
Self::filter_out_parenthesized_tokens(arg.tokens())
115+
.iter().map(|t| t.range)
35116
);
36117
}
37118
if filtered_member_ranges.is_empty()
@@ -40,44 +121,44 @@ impl FuncCallBreakOnOpeningParenArgs {
40121
filtered_member_ranges.first()?.to_owned()) {
41122
return None
42123
}
43-
Some(FuncCallBreakOnOpeningParenArgs {
44-
member_ranges: filtered_member_ranges,
124+
Some(FuncCallBreakOnOpenParenArgs {
125+
members_ranges: filtered_member_ranges,
45126
expected_depth: depth,
127+
lparen: node.lparen.range(),
46128
})
47129
}
48-
}
49130

50-
impl FuncCallBreakOnOpeningParen {
51-
pub fn check(&self, acc: &mut Vec<DMLStyleError>, args: Option<FuncCallBreakOnOpeningParenArgs>) {
52-
if !self.enabled {
53-
return;
54-
}
55-
let Some(args) = args else { return; };
56-
// TODO : enable shared access to indentation_spaces param for all related rules
57-
let expected_line_start = args.expected_depth * 4; // Assuming 4 spaces per indent level
58-
let mut last_row = args.member_ranges.first().unwrap().row_start.0;
131+
pub fn from_paren_expression(node: &ParenExpressionContent, depth: u32) -> Option<FuncCallBreakOnOpenParenArgs> {
132+
Some(FuncCallBreakOnOpenParenArgs {
133+
members_ranges: Self::filter_out_parenthesized_tokens(node.expr.tokens())
134+
.iter().map(|t| t.range).collect(),
135+
expected_depth: depth,
136+
lparen: node.lparen.range(),
137+
})
138+
}
59139

60-
for member_range in args.member_ranges {
61-
if member_range.row_start.0 != last_row {
62-
last_row = member_range.row_start.0;
63-
if member_range.col_start.0 != expected_line_start {
64-
acc.push(self.create_err(member_range));
65-
}
66-
}
140+
pub fn from_method(node: &MethodContent, depth: u32) -> Option<FuncCallBreakOnOpenParenArgs> {
141+
let mut filtered_member_ranges: Vec<ZeroRange> = vec![];
142+
for (arg, _comma) in node.arguments.iter() {
143+
filtered_member_ranges.extend(
144+
Self::filter_out_parenthesized_tokens(arg.tokens())
145+
.iter().map(|t| t.range));
67146
}
147+
Some(FuncCallBreakOnOpenParenArgs {
148+
members_ranges: filtered_member_ranges,
149+
expected_depth: depth,
150+
lparen: node.lparen.range(),
151+
})
68152
}
69-
}
70153

71-
impl Rule for FuncCallBreakOnOpeningParen {
72-
fn name() -> &'static str {
73-
"FUNC_CALL_BREAK_ON_OPENING_PAREN"
74-
}
75-
fn description() -> &'static str {
76-
"Function or method calls broken right after opening parenthesis should
77-
indent continuation lines one more level."
78-
}
79-
fn get_rule_type() -> RuleType {
80-
RuleType::LL6
154+
pub fn from_cast(node: &CastContent, depth: u32) -> Option<FuncCallBreakOnOpenParenArgs> {
155+
let mut cast_member_tokens = node.from.tokens();
156+
cast_member_tokens.append(&mut node.to.tokens());
157+
Some(FuncCallBreakOnOpenParenArgs {
158+
members_ranges: Self::filter_out_parenthesized_tokens(cast_member_tokens)
159+
.iter().map(|t| t.range).collect(),
160+
expected_depth: depth,
161+
lparen: node.lparen.range(),
162+
})
81163
}
82164
}
83-

‎src/lint/rules/mod.rs‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -9,7 +9,7 @@ use spacing::{SpBracesRule,
99
SpPunctRule, NspFunparRule, NspInparenRule,
1010
NspUnaryRule, NspTrailingRule};
1111
use indentation::{LongLinesRule, IndentNoTabRule, IndentCodeBlockRule, IndentClosingBraceRule, IndentParenExprRule, IndentSwitchCaseRule, IndentEmptyLoopRule, IndentContinuationLineRule};
12-
use linebreaking::FuncCallBreakOnOpeningParen;
12+
use linebreaking::FuncCallBreakOnOpenParenRule;
1313
use crate::lint::{LintCfg, DMLStyleError};
1414
use crate::analysis::{LocalDMLError, parsing::tree::ZeroRange};
1515

@@ -28,7 +28,7 @@ pub struct CurrentRules {
2828
pub indent_switch_case: IndentSwitchCaseRule,
2929
pub indent_empty_loop: IndentEmptyLoopRule,
3030
pub indent_continuation_line: IndentContinuationLineRule,
31-
pub func_call_break_on_opening_paren: FuncCallBreakOnOpeningParen,
31+
pub func_call_break_on_open_paren: FuncCallBreakOnOpenParenRule,
3232
}
3333

3434
pub fn instantiate_rules(cfg: &LintCfg) -> CurrentRules {
@@ -47,7 +47,7 @@ pub fn instantiate_rules(cfg: &LintCfg) -> CurrentRules {
4747
indent_switch_case: IndentSwitchCaseRule::from_options(&cfg.indent_switch_case),
4848
indent_empty_loop: IndentEmptyLoopRule::from_options(&cfg.indent_empty_loop),
4949
indent_continuation_line: IndentContinuationLineRule::from_options(&cfg.indent_continuation_line),
50-
func_call_break_on_opening_paren: FuncCallBreakOnOpeningParen { enabled: cfg.func_call_break_on_opening_paren.is_some() },
50+
func_call_break_on_open_paren: FuncCallBreakOnOpenParenRule::from_options(&cfg.func_call_break_on_open_paren),
5151
}
5252
}
5353

‎src/lint/rules/tests/indentation/paren_expr.rs‎

Lines changed: 4 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -90,20 +90,6 @@ fn funcall_paren_incorrect() {
9090
assert_snippet(FUNCALL_PAREN_INCORRECT, expected_errors, &rules);
9191
}
9292

93-
static FUNCALL_BROKEN_AFTER_PAREN_EXCEPTION_CORRECT: &str = "
94-
method effect() {
95-
callback(
96-
0xABC,
97-
identifier,
98-
false);
99-
}
100-
";
101-
#[test]
102-
fn funcall_broken_after_paren_exception_correct() {
103-
let rules = set_up();
104-
assert_snippet(FUNCALL_BROKEN_AFTER_PAREN_EXCEPTION_CORRECT, vec![], &rules);
105-
}
106-
10793
static FUNCALL_NESTED_PAREN_CORRECT: &str = "
10894
method effect() {
10995
callback(another_cb(varname,
@@ -361,8 +347,7 @@ fn switch_paren_incorrect() {
361347
}
362348

363349
static NESTED_PAREN_EXPR_CORRECT: &str = "
364-
param result = (
365-
(reg0.val
350+
param result = ((reg0.val
366351
* reg1.enable.val)
367352
&
368353
mask_reg
@@ -377,8 +362,7 @@ fn nested_paren_expr_correct(){
377362
}
378363

379364
static NESTED_PAREN_EXPR_INCORRECT: &str = "
380-
param result = (
381-
(reg0.val
365+
param result = ((reg0.val
382366
* reg1.enable.val)
383367
&
384368
mask_reg
@@ -391,8 +375,8 @@ fn nested_paren_expr_incorrect(){
391375
let rules = set_up();
392376
let expected_errors = define_expected_errors!(
393377
RuleType::IN5,
394-
(2, 2, 4, 5),
395-
(5, 5, 17, 25),
378+
(2, 2, 5, 6),
379+
(4, 4, 17, 25),
396380
);
397381
assert_snippet(NESTED_PAREN_EXPR_INCORRECT, expected_errors, &rules);
398382
}

0 commit comments

Comments
 (0)