Apply consistent naming convention for linelength rules

Author: jvsqzj

example_files/example_lint_cfg.json

@@ -19,9 +19,9 @@
     "indent_switch_case": {},
     "indent_empty_loop": {},
     "indent_continuation_line": {},
-    "func_call_break_on_open_paren": {},
-    "method_output_break": {},
-    "conditional_expression_break_before_op": {},
+    "break_func_call_open_paren": {},
+    "break_method_output": {},
+    "break_conditional_expression": {},
     "break_before_binary_op": {},
     "annotate_lints": true
 }

src/analysis/parsing/expression.rs

@@ -27,9 +27,9 @@ use crate::lint::{DMLStyleError,
                                     CurrentRules},
                                     AuxParams};
 use crate::lint::rules::indentation::IndentParenExprArgs;
-use crate::lint::rules::linebreaking::{BreakBeforeBinaryOpArgs,
-    ConditionalExpressionBreakBeforeOperatorArgs,
-    FuncCallBreakOnOpenParenArgs};
+use crate::lint::rules::linelength::{BreakBeforeBinaryOpArgs,
+    BreakConditionalExpression,
+    BreakFuncCallOpenParenArgs};
 
 #[derive(Debug, Clone, PartialEq)]
 pub struct UnaryExpressionContent {
@@ -162,8 +162,8 @@ impl TreeElement for TertiaryExpressionContent {
     }
     fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, _aux: AuxParams) {
         rules.sp_ternary.check(SpTernaryArgs::from_tertiary_expression_content(self), acc);
-        rules.conditional_expression_break_before_op
-            .check(ConditionalExpressionBreakBeforeOperatorArgs::from_tertiary_expression(self), acc);
+        rules.break_conditional_expression
+            .check(BreakConditionalExpression::from_tertiary_expression(self), acc);
     }
 }
 
@@ -183,8 +183,8 @@ impl TreeElement for ParenExpressionContent {
     }
     fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, aux: AuxParams) {
         rules.indent_paren_expr.check(IndentParenExprArgs::from_paren_expression(self), acc);
-        rules.func_call_break_on_open_paren.check(
-            FuncCallBreakOnOpenParenArgs::from_paren_expression(self, aux.depth), acc);
+        rules.break_func_call_open_paren.check(
+            BreakFuncCallOpenParenArgs::from_paren_expression(self, aux.depth), acc);
     }
 }
 
@@ -235,8 +235,8 @@ impl TreeElement for FunctionCallContent {
         rules.nsp_inparen.check(NspInparenArgs::from_function_call(self), acc);
         rules.sp_punct.check(SpPunctArgs::from_function_call(self), acc);
         rules.indent_paren_expr.check(IndentParenExprArgs::from_function_call(self), acc);
-        rules.func_call_break_on_open_paren
-            .check(FuncCallBreakOnOpenParenArgs::from_function_call(self, aux.depth), acc);
+        rules.break_func_call_open_paren
+            .check(BreakFuncCallOpenParenArgs::from_function_call(self, aux.depth), acc);
     }
 }
 
@@ -352,8 +352,8 @@ impl TreeElement for CastContent {
     }
     fn evaluate_rules(&self, acc: &mut Vec<DMLStyleError>, rules: &CurrentRules, aux: AuxParams) {
         rules.indent_paren_expr.check(IndentParenExprArgs::from_cast(self), acc);
-        rules.func_call_break_on_open_paren
-            .check(FuncCallBreakOnOpenParenArgs::from_cast(self, aux.depth), acc);
+        rules.break_func_call_open_paren
+            .check(BreakFuncCallOpenParenArgs::from_cast(self, aux.depth), acc);
     }
 }
 

src/analysis/parsing/structure.rs

@@ -16,7 +16,7 @@ use crate::analysis::parsing::parser::{doesnt_understand_tokens,
                                        FileParser, Parse, ParseContext,
                                        FileInfo};
 use crate::analysis::LocalDMLError;
-use crate::lint::rules::linebreaking::{FuncCallBreakOnOpenParenArgs, MethodOutputBreakArgs};
+use crate::lint::rules::linelength::{BreakFuncCallOpenParenArgs, BreakMethodOutputArgs};
 use crate::lint::rules::spacing::{SpBracesArgs,
                                   NspInparenArgs,
                                   NspFunparArgs,
@@ -244,8 +244,8 @@ impl TreeElement for MethodContent {
         rules.nsp_inparen.check(NspInparenArgs::from_method(self), acc);
         rules.sp_punct.check(SpPunctArgs::from_method(self), acc);
         rules.indent_paren_expr.check(IndentParenExprArgs::from_method(self), acc);
-        rules.func_call_break_on_open_paren.check(FuncCallBreakOnOpenParenArgs::from_method(self, aux.depth), acc);
-        rules.method_output_break.check(MethodOutputBreakArgs::from_method(self), acc);
+        rules.break_func_call_open_paren.check(BreakFuncCallOpenParenArgs::from_method(self, aux.depth), acc);
+        rules.break_method_output.check(BreakMethodOutputArgs::from_method(self), acc);
     }
 }
 

src/lint/features.md

@@ -53,8 +53,8 @@ Below are listed the currently supported rules for linting:
          + another_very_long_expression)
         * a_third_long_expression;
 ```
-- **LL3**, `conditional_expression_break`: Break conditional expressions before the ?, or both before the ? and before the :.
-- **LL5**, `method_output_break`: Break long method declarations with output parameters before the arrow.
+- **LL3**, `break_conditional_expression`: Break conditional expressions before the ?, or both before the ? and before the :.
+- **LL5**, `break_method_output`: Break long method declarations with output parameters before the arrow.
 ```
     method inquiry_status(uint64 physical_address)
         -> (uint16 status) {

src/lint/mod.rs

@@ -5,10 +5,10 @@ use std::path::{Path, PathBuf};
 use std::str::FromStr;
 use lazy_static::lazy_static;
 use log::{debug, error, trace};
-use rules::linebreaking::{BreakBeforeBinaryOpOptions,
-    FuncCallBreakOnOpenParenOptions,
-    MethodOutputBreakOptions,
-    ConditionalExpressionBreakBeforeOperatorOptions};
+use rules::linelength::{BreakBeforeBinaryOpOptions,
+    BreakFuncCallOpenParenOptions,
+    BreakMethodOutputOptions,
+    BreakConditionalExpressionOptions};
 use serde::{Deserialize, Serialize};
 use regex::Regex;
 use rules::{instantiate_rules, CurrentRules, RuleType};
@@ -118,11 +118,11 @@ pub struct LintCfg {
     #[serde(default)]
     pub indent_continuation_line: Option<IndentContinuationLineOptions>,
     #[serde(default)]
-    pub func_call_break_on_open_paren: Option<FuncCallBreakOnOpenParenOptions>,
+    pub break_func_call_open_paren: Option<BreakFuncCallOpenParenOptions>,
     #[serde(default)]
-    pub conditional_expression_break_before_op: Option<ConditionalExpressionBreakBeforeOperatorOptions>,
+    pub break_conditional_expression: Option<BreakConditionalExpressionOptions>,
     #[serde(default)]
-    pub method_output_break: Option<MethodOutputBreakOptions>,
+    pub break_method_output: Option<BreakMethodOutputOptions>,
     #[serde(default)]
     pub break_before_binary_op: Option<BreakBeforeBinaryOpOptions>,
     #[serde(default = "get_true")]
@@ -171,9 +171,9 @@ impl Default for LintCfg {
             indent_switch_case: Some(IndentSwitchCaseOptions{indentation_spaces: INDENTATION_LEVEL_DEFAULT}),
             indent_empty_loop: Some(IndentEmptyLoopOptions{indentation_spaces: INDENTATION_LEVEL_DEFAULT}),
             indent_continuation_line: Some(IndentContinuationLineOptions{indentation_spaces: INDENTATION_LEVEL_DEFAULT}),
-            func_call_break_on_open_paren: Some(FuncCallBreakOnOpenParenOptions{indentation_spaces: INDENTATION_LEVEL_DEFAULT}),
-            method_output_break: Some(MethodOutputBreakOptions{}),
-            conditional_expression_break_before_op: Some(ConditionalExpressionBreakBeforeOperatorOptions{}),
+            break_func_call_open_paren: Some(BreakFuncCallOpenParenOptions{indentation_spaces: INDENTATION_LEVEL_DEFAULT}),
+            break_method_output: Some(BreakMethodOutputOptions{}),
+            break_conditional_expression: Some(BreakConditionalExpressionOptions{}),
             break_before_binary_op: Some(BreakBeforeBinaryOpOptions{}),
             annotate_lints: true,
         }

src/lint/rules/linebreaking.rs renamed to src/lint/rules/linelength.rs

@@ -16,23 +16,23 @@ fn default_indentation_spaces() -> u32 {
     INDENTATION_LEVEL_DEFAULT
 }
 
-pub struct MethodOutputBreakRule {
+pub struct BreakMethodOutputRule {
     pub enabled: bool
 }
 
-pub struct MethodOutputBreakArgs {
+pub struct BreakMethodOutputArgs {
     pub before_arrow_range: ZeroRange,
     pub arrow_range: ZeroRange,
     pub after_arrow_range: ZeroRange,
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-pub struct MethodOutputBreakOptions{
+pub struct BreakMethodOutputOptions{
 }
 
-impl Rule for MethodOutputBreakRule {
+impl Rule for BreakMethodOutputRule {
     fn name() -> &'static str {
-        "method_output_break"
+        "break_method_output"
     }
     fn description() -> &'static str {
         "Break long method declarations with output parameters before the arrow."
@@ -42,19 +42,19 @@ impl Rule for MethodOutputBreakRule {
     }
 }
 
-impl MethodOutputBreakArgs {
-    pub fn from_method(node: &MethodContent) -> Option<MethodOutputBreakArgs> {
+impl BreakMethodOutputArgs {
+    pub fn from_method(node: &MethodContent) -> Option<BreakMethodOutputArgs> {
         let Some(returns) = &node.returns else { return None; };
-        Some(MethodOutputBreakArgs {
+        Some(BreakMethodOutputArgs {
             before_arrow_range: node.rparen.range(),
             arrow_range: returns.0.range(),
             after_arrow_range: returns.1.range(),
         })
     }
 }
 
-impl MethodOutputBreakRule {
-    pub fn check(&self, args: Option<MethodOutputBreakArgs>, acc: &mut Vec<DMLStyleError>) {
+impl BreakMethodOutputRule {
+    pub fn check(&self, args: Option<BreakMethodOutputArgs>, acc: &mut Vec<DMLStyleError>) {
         if !self.enabled { return; }
         let Some(args) = args else { return; };
         if args.before_arrow_range.row_end.0 == args.after_arrow_range.row_start.0 {
@@ -68,26 +68,26 @@ impl MethodOutputBreakRule {
     }
 }
 
-pub struct FuncCallBreakOnOpenParenRule {
+pub struct BreakFuncCallOpenParenRule {
     pub enabled: bool,
     indentation_spaces: u32
 }
 
-pub struct FuncCallBreakOnOpenParenArgs {
+pub struct BreakFuncCallOpenParenArgs {
     pub members_ranges: Vec<ZeroRange>,
     pub expected_depth: u32,
     pub lparen: ZeroRange,
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-pub struct FuncCallBreakOnOpenParenOptions{
+pub struct BreakFuncCallOpenParenOptions{
     #[serde(default = "default_indentation_spaces")]
     pub indentation_spaces: u32,
 }
 
-impl Rule for FuncCallBreakOnOpenParenRule {
+impl Rule for BreakFuncCallOpenParenRule {
     fn name() -> &'static str {
-        "FUNC_CALL_BREAK_ON_OPEN_PAREN"
+        "break_func_call_open_paren"
     }
     fn description() -> &'static str {
         "Function or method calls broken right after opening parenthesis should
@@ -98,7 +98,7 @@ impl Rule for FuncCallBreakOnOpenParenRule {
     }
 }
 
-impl FuncCallBreakOnOpenParenArgs {
+impl BreakFuncCallOpenParenArgs {
     pub fn filter_out_parenthesized_tokens(expression_tokens: TreeElementTokenIterator) -> Vec<Token> {
         let mut token_list: Vec<Token> = vec![];
         let mut paren_depth = 0;
@@ -125,7 +125,7 @@ impl FuncCallBreakOnOpenParenArgs {
         }
         token_list
     }
-    pub fn from_function_call(node: &FunctionCallContent, depth: u32) -> Option<FuncCallBreakOnOpenParenArgs> {
+    pub fn from_function_call(node: &FunctionCallContent, depth: u32) -> Option<BreakFuncCallOpenParenArgs> {
         let mut filtered_member_ranges: Vec<ZeroRange> = vec![];
         for (arg, _comma) in node.arguments.iter() {
             filtered_member_ranges.extend(
@@ -139,40 +139,40 @@ impl FuncCallBreakOnOpenParenArgs {
                 filtered_member_ranges.first()?.to_owned()) {
             return None
         }
-        Some(FuncCallBreakOnOpenParenArgs {
+        Some(BreakFuncCallOpenParenArgs {
             members_ranges: filtered_member_ranges,
             expected_depth: depth,
             lparen: node.lparen.range(),
         })
     }
 
-    pub fn from_paren_expression(node: &ParenExpressionContent, depth: u32) -> Option<FuncCallBreakOnOpenParenArgs> {
-        Some(FuncCallBreakOnOpenParenArgs {
+    pub fn from_paren_expression(node: &ParenExpressionContent, depth: u32) -> Option<BreakFuncCallOpenParenArgs> {
+        Some(BreakFuncCallOpenParenArgs {
             members_ranges: Self::filter_out_parenthesized_tokens(node.expr.tokens())
                 .iter().map(|t| t.range).collect(),
             expected_depth: depth,
             lparen: node.lparen.range(),
         })
     }
 
-    pub fn from_method(node: &MethodContent, depth: u32) -> Option<FuncCallBreakOnOpenParenArgs> {
+    pub fn from_method(node: &MethodContent, depth: u32) -> Option<BreakFuncCallOpenParenArgs> {
         let mut filtered_member_ranges: Vec<ZeroRange> = vec![];
         for (arg, _comma) in node.arguments.iter() {
             filtered_member_ranges.extend(
                 Self::filter_out_parenthesized_tokens(arg.tokens())
                     .iter().map(|t| t.range));
         }
-        Some(FuncCallBreakOnOpenParenArgs {
+        Some(BreakFuncCallOpenParenArgs {
             members_ranges: filtered_member_ranges,
             expected_depth: depth,
             lparen: node.lparen.range(),
         })
     }
 
-    pub fn from_cast(node: &CastContent, depth: u32) -> Option<FuncCallBreakOnOpenParenArgs> {
+    pub fn from_cast(node: &CastContent, depth: u32) -> Option<BreakFuncCallOpenParenArgs> {
         let mut cast_member_tokens = node.from.tokens();
         cast_member_tokens.append(&mut node.to.tokens());
-        Some(FuncCallBreakOnOpenParenArgs {
+        Some(BreakFuncCallOpenParenArgs {
             members_ranges: Self::filter_out_parenthesized_tokens(cast_member_tokens)
                 .iter().map(|t| t.range).collect(),
             expected_depth: depth,
@@ -181,21 +181,21 @@ impl FuncCallBreakOnOpenParenArgs {
     }
 }
 
-impl FuncCallBreakOnOpenParenRule {
-    pub fn from_options(options: &Option<FuncCallBreakOnOpenParenOptions>) -> FuncCallBreakOnOpenParenRule {
+impl BreakFuncCallOpenParenRule {
+    pub fn from_options(options: &Option<BreakFuncCallOpenParenOptions>) -> BreakFuncCallOpenParenRule {
         match options {
-            Some(options) => FuncCallBreakOnOpenParenRule {
+            Some(options) => BreakFuncCallOpenParenRule {
                 enabled: true,
                 indentation_spaces: options.indentation_spaces
             },
-            None => FuncCallBreakOnOpenParenRule {
+            None => BreakFuncCallOpenParenRule {
                 enabled: false,
                 indentation_spaces: 0
             }
         }
     }
 
-    pub fn check(&self, args: Option<FuncCallBreakOnOpenParenArgs>, acc: &mut Vec<DMLStyleError>) {
+    pub fn check(&self, args: Option<BreakFuncCallOpenParenArgs>, acc: &mut Vec<DMLStyleError>) {
         if !self.enabled { return; }
         let Some(args) = args else { return; };
         if args.members_ranges.is_empty() { return; }
@@ -271,11 +271,11 @@ impl Rule for BreakBeforeBinaryOpRule {
     }
 }
 
-pub struct ConditionalExpressionBreakBeforeOperatorRule {
+pub struct BreakConditionalExpressionRule {
     pub enabled: bool,
 }
 
-pub struct ConditionalExpressionBreakBeforeOperatorArgs {
+pub struct BreakConditionalExpression {
     pub left: ZeroRange,
     pub left_operation: ZeroRange,
     pub middle: ZeroRange,
@@ -284,10 +284,10 @@ pub struct ConditionalExpressionBreakBeforeOperatorArgs {
 }
 
 
-impl ConditionalExpressionBreakBeforeOperatorArgs {
+impl BreakConditionalExpression {
     pub fn from_tertiary_expression(node: &TertiaryExpressionContent) 
-        -> Option<ConditionalExpressionBreakBeforeOperatorArgs> {
-        Some(ConditionalExpressionBreakBeforeOperatorArgs {
+        -> Option<BreakConditionalExpression> {
+        Some(BreakConditionalExpression {
             left: node.left.range(),
             left_operation: node.left_operation.range(),
             middle: node.middle.range(),
@@ -297,19 +297,19 @@ impl ConditionalExpressionBreakBeforeOperatorArgs {
     }
 }
 
-impl ConditionalExpressionBreakBeforeOperatorRule {
-    pub fn from_options(options: &Option<ConditionalExpressionBreakBeforeOperatorOptions>) -> ConditionalExpressionBreakBeforeOperatorRule {
+impl BreakConditionalExpressionRule {
+    pub fn from_options(options: &Option<BreakConditionalExpressionOptions>) -> BreakConditionalExpressionRule {
         match options {
-            Some(_options) => ConditionalExpressionBreakBeforeOperatorRule {
+            Some(_options) => BreakConditionalExpressionRule {
                 enabled: true,
             },
-            None => ConditionalExpressionBreakBeforeOperatorRule {
+            None => BreakConditionalExpressionRule {
                 enabled: false,
             }
         }
     }
 
-    pub fn check(&self, args: Option<ConditionalExpressionBreakBeforeOperatorArgs>, acc: &mut Vec<DMLStyleError>) {
+    pub fn check(&self, args: Option<BreakConditionalExpression>, acc: &mut Vec<DMLStyleError>) {
         if !self.enabled { return; }
         let Some(args) = args else { return; };
         let has_break_before_question_operator = args.left.row_end.0 != args.left_operation.row_start.0;
@@ -327,12 +327,12 @@ impl ConditionalExpressionBreakBeforeOperatorRule {
 
 
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-pub struct ConditionalExpressionBreakBeforeOperatorOptions{
+pub struct BreakConditionalExpressionOptions{
 }
 
-impl Rule for ConditionalExpressionBreakBeforeOperatorRule {
+impl Rule for BreakConditionalExpressionRule {
     fn name() -> &'static str {
-        "COND_EXPRESSION_BREAK_BEFORE_OPERATOR"
+        "break_conditional_expression"
     }
     fn description() -> &'static str {
         "Break conditional expressions before the ?, or both before the ? and before the :."