Use argparse config handler in design_analysis.py (#6118)

Author: DanielNoord

pylint/checkers/design_analysis.py

@@ -403,7 +403,7 @@ class MisdesignChecker(BaseChecker):
     )
 
     def __init__(self, linter=None):
-        super().__init__(linter)
+        super().__init__(linter, future_option_parsing=True)
         self._returns = None
         self._branches = None
         self._stmts = None
@@ -435,21 +435,22 @@ def _ignored_argument_names(self):
     def visit_classdef(self, node: nodes.ClassDef) -> None:
         """Check size of inheritance hierarchy and number of instance attributes."""
         parents = _get_parents(
-            node, STDLIB_CLASSES_IGNORE_ANCESTOR.union(self.config.ignored_parents)
+            node,
+            STDLIB_CLASSES_IGNORE_ANCESTOR.union(self.linter.namespace.ignored_parents),
         )
         nb_parents = len(parents)
-        if nb_parents > self.config.max_parents:
+        if nb_parents > self.linter.namespace.max_parents:
             self.add_message(
                 "too-many-ancestors",
                 node=node,
-                args=(nb_parents, self.config.max_parents),
+                args=(nb_parents, self.linter.namespace.max_parents),
             )
 
-        if len(node.instance_attrs) > self.config.max_attributes:
+        if len(node.instance_attrs) > self.linter.namespace.max_attributes:
             self.add_message(
                 "too-many-instance-attributes",
                 node=node,
-                args=(len(node.instance_attrs), self.config.max_attributes),
+                args=(len(node.instance_attrs), self.linter.namespace.max_attributes),
             )
 
     @check_messages("too-few-public-methods", "too-many-public-methods")
@@ -466,11 +467,11 @@ def leave_classdef(self, node: nodes.ClassDef) -> None:
         # for classes such as unittest.TestCase, which provides
         # a lot of assert methods. It doesn't make sense to warn
         # when the user subclasses TestCase to add his own tests.
-        if my_methods > self.config.max_public_methods:
+        if my_methods > self.linter.namespace.max_public_methods:
             self.add_message(
                 "too-many-public-methods",
                 node=node,
-                args=(my_methods, self.config.max_public_methods),
+                args=(my_methods, self.linter.namespace.max_public_methods),
             )
 
         # Stop here if the class is excluded via configuration.
@@ -491,11 +492,11 @@ def leave_classdef(self, node: nodes.ClassDef) -> None:
         # This checks all the methods defined by ancestors and
         # by the current class.
         all_methods = _count_methods_in_class(node)
-        if all_methods < self.config.min_public_methods:
+        if all_methods < self.linter.namespace.min_public_methods:
             self.add_message(
                 "too-few-public-methods",
                 node=node,
-                args=(all_methods, self.config.min_public_methods),
+                args=(all_methods, self.linter.namespace.min_public_methods),
             )
 
     @check_messages(
@@ -523,19 +524,21 @@ def visit_functiondef(self, node: nodes.FunctionDef) -> None:
                 )
 
             argnum = len(args) - ignored_args_num
-            if argnum > self.config.max_args:
+            if argnum > self.linter.namespace.max_args:
                 self.add_message(
                     "too-many-arguments",
                     node=node,
-                    args=(len(args), self.config.max_args),
+                    args=(len(args), self.linter.namespace.max_args),
                 )
         else:
             ignored_args_num = 0
         # check number of local variables
         locnum = len(node.locals) - ignored_args_num
-        if locnum > self.config.max_locals:
+        if locnum > self.linter.namespace.max_locals:
             self.add_message(
-                "too-many-locals", node=node, args=(locnum, self.config.max_locals)
+                "too-many-locals",
+                node=node,
+                args=(locnum, self.linter.namespace.max_locals),
             )
         # init new statements counter
         self._stmts.append(1)
@@ -554,26 +557,26 @@ def leave_functiondef(self, node: nodes.FunctionDef) -> None:
         checks for max returns, branch, return in __init__
         """
         returns = self._returns.pop()
-        if returns > self.config.max_returns:
+        if returns > self.linter.namespace.max_returns:
             self.add_message(
                 "too-many-return-statements",
                 node=node,
-                args=(returns, self.config.max_returns),
+                args=(returns, self.linter.namespace.max_returns),
             )
         branches = self._branches[node]
-        if branches > self.config.max_branches:
+        if branches > self.linter.namespace.max_branches:
             self.add_message(
                 "too-many-branches",
                 node=node,
-                args=(branches, self.config.max_branches),
+                args=(branches, self.linter.namespace.max_branches),
             )
         # check number of statements
         stmts = self._stmts.pop()
-        if stmts > self.config.max_statements:
+        if stmts > self.linter.namespace.max_statements:
             self.add_message(
                 "too-many-statements",
                 node=node,
-                args=(stmts, self.config.max_statements),
+                args=(stmts, self.linter.namespace.max_statements),
             )
 
     leave_asyncfunctiondef = leave_functiondef
@@ -625,11 +628,11 @@ def _check_boolean_expressions(self, node):
         if not isinstance(condition, astroid.BoolOp):
             return
         nb_bool_expr = _count_boolean_expressions(condition)
-        if nb_bool_expr > self.config.max_bool_expr:
+        if nb_bool_expr > self.linter.namespace.max_bool_expr:
             self.add_message(
                 "too-many-boolean-expressions",
                 node=condition,
-                args=(nb_bool_expr, self.config.max_bool_expr),
+                args=(nb_bool_expr, self.linter.namespace.max_bool_expr),
             )
 
     def visit_while(self, node: nodes.While) -> None:

pylint/config/argument.py

@@ -14,7 +14,9 @@
 
 from pylint import utils as pylint_utils
 
-_ArgumentTypes = Union[str, Sequence[str], int, Pattern[str], bool]
+_ArgumentTypes = Union[
+    str, Sequence[str], int, Pattern[str], bool, Sequence[Pattern[str]]
+]
 """List of possible argument types."""
 
 
@@ -46,12 +48,21 @@ def _non_empty_string_transformer(value: str) -> str:
     return pylint_utils._unquote(value)
 
 
+def _regexp_csv_transfomer(value: str) -> Sequence[Pattern[str]]:
+    """Transforms a comma separated list of regular expressions."""
+    patterns: List[Pattern[str]] = []
+    for pattern in _csv_transformer(value):
+        patterns.append(re.compile(pattern))
+    return patterns
+
+
 _TYPE_TRANSFORMERS: Dict[str, Callable[[str], _ArgumentTypes]] = {
     "choice": str,
     "csv": _csv_transformer,
     "int": int,
     "non_empty_string": _non_empty_string_transformer,
     "regexp": re.compile,
+    "regexp_csv": _regexp_csv_transfomer,
     "string": str,
     "yn": _yn_transformer,
 }