fix(indentation_namespace): false positive for MemInitLists

aaronliu0130 · aaronliu0130 · commit 5ae674ca0bfb · 2025-04-07T19:18:40.000-04:00
Fix whitespace/indentation_namespace false positive for member initializer lists (MemInitLists)
Adds new _ConstructorInfo, _WrappedInfo, and _MemInitListInfo nesting stack element classes
Remember last-popped nesting stack item
Update descriptor.pb.cc to 2016-12-16 version (commit 183d31c)
diff --git a/CHANGELOG.rst b/CHANGELOG.rst
@@ -6,8 +6,7 @@ Changelog
 ===========
 
 * Python versions less than 3.9 are no longer supported.
-* The false positive for indented function parameters in namespaces was eradicated. (https://github.com/cpplint/cpplint/pull/304)
-* build/include-what-you-use now recognizes c-style headers, such as <stdio.h> for symbols from <cstdio>. (https://github.com/cpplint/cpplint/pull/319)
+* The false positive for indented member initializer lists in namespaces were eradicated. (https://github.com/cpplint/cpplint/pull/353)
 * The warning on non-const references (runtime/references) is now disabled by default pursuant to the May 2020 Google style guide update. (https://github.com/cpplint/cpplint/pull/305)
 
 2.0.1 (2025-03-09)
diff --git a/cpplint.py b/cpplint.py
@@ -3097,6 +3097,14 @@ def CheckEnd(self, filename, clean_lines, linenum, error):
             )
 
 
+class _ConstructorInfo(_BlockInfo):
+    """Stores information about a constructor.
+    For detecting member initializer lists."""
+
+    def __init__(self, linenum: int):
+        _BlockInfo.__init__(self, linenum, seen_open_brace=False)
+
+
 class _NamespaceInfo(_BlockInfo):
     """Stores information about a namespace."""
 
@@ -3174,6 +3182,22 @@ def CheckEnd(self, filename, clean_lines, linenum, error):
                     )
 
 
+class _WrappedInfo(_BlockInfo):
+    """Stores information about parentheses, initializer lists, etc.
+    Not exactly a block but we do need the same signature.
+    Needed to avoid namespace indentation false positives,
+    though parentheses tracking would slow us down a lot
+    and is effectively already done by open_parentheses."""
+
+    pass
+
+
+class _MemInitListInfo(_WrappedInfo):
+    """Stores information about member initializer lists."""
+
+    pass
+
+
 class _PreprocessorInfo:
     """Stores checkpoints of nesting stacks when #if/#else is seen."""
 
@@ -3216,6 +3240,9 @@ def __init__(self):
         # We can't use previous_stack_top, a shallow copy whose open_parentheses value is updated.
         self.previous_open_parentheses = 0
 
+        # The last stack item we popped.
+        self.popped_top: _BlockInfo | None = None
+
         # Stack of _PreprocessorInfo objects.
         self.pp_stack = []
 
@@ -3370,6 +3397,9 @@ def UpdatePreprocessor(self, line):
                 # TODO(google): unexpected #endif, issue warning?
                 pass
 
+    def _Pop(self):
+        """Pop the innermost state (top of the stack) and remember the popped item."""
+        self.popped_top = self.stack.pop()
 
     def _CountOpenParentheses(self, line: str):
         # Count parentheses.  This is to avoid adding struct arguments to
@@ -3423,6 +3453,22 @@ def _UpdateNamesapce(self, line: str, linenum: int) -> str | None:
             line = line[line.find("{") + 1 :]
         return line
 
+    def _UpdateConstructor(self, line: str, linenum: int, class_name: str | None = None):
+        """
+        Check if the given line is a constructor.
+        Args:
+            line: Line to check.
+            class_name: If line checked is inside of a class block, a str of the class's name;
+                otherwise, None.
+        """
+        if not class_name:
+            if not re.match(r"\s*(\w*)\s*::\s*\1\s*\(", line):
+                return
+        elif not re.match(rf"\s*{re.escape(class_name)}\s*\(", line):
+            return
+
+        self.stack.append(_ConstructorInfo(linenum))
+
     # TODO(google): Update() is too long, but we will refactor later.
     def Update(self, filename: str, clean_lines: CleansedLines, linenum: int, error):
         """Update nesting state with current line.
@@ -3492,36 +3538,56 @@ def Update(self, filename: str, clean_lines: CleansedLines, linenum: int, error)
         if not self.SeenOpenBrace():
             self.stack[-1].CheckBegin(filename, clean_lines, linenum, error)
 
-        # Update access control if we are inside a class/struct
+        # Update access control if we are directly inside a class/struct
         if self.stack and isinstance(self.stack[-1], _ClassInfo):
-            classinfo = self.stack[-1]
-            access_match = re.match(
-                r"^(.*)\b(public|private|protected|signals)(\s+(?:slots\s*)?)?"
-                r":(?:[^:]|$)",
-                line,
+            if self.stack[-1].seen_open_brace:
+                classinfo: _ClassInfo = self.stack[-1]
+                # Update access control
+                if access_match := re.match(
+                    r"^(.*)\b(public|private|protected|signals)(\s+(?:slots\s*)?)?"
+                    r":([^:].*|$)",
+                    line,
+                ):
+                    classinfo.access = access_match.group(2)
+
+                    # Check that access keywords are indented +1 space.  Skip this
+                    # check if the keywords are not preceded by whitespaces.
+                    indent = access_match.group(1)
+                    if len(indent) != classinfo.class_indent + 1 and re.match(r"^\s*$", indent):
+                        if classinfo.is_struct:
+                            parent = "struct " + classinfo.name
+                        else:
+                            parent = "class " + classinfo.name
+                        slots = ""
+                        if access_match.group(3):
+                            slots = access_match.group(3)
+                        error(
+                            filename,
+                            linenum,
+                            "whitespace/indent",
+                            3,
+                            f"{access_match.group(2)}{slots}:"
+                            f" should be indented +1 space inside {parent}",
+                        )
+
+                    line = access_match.group(4)
+                else:
+                    self._UpdateConstructor(line, linenum, class_name=classinfo.name)
+        else:  # Not in class
+            self._UpdateConstructor(line, linenum)
+
+        # If brace not open and we just finished a parenthetical definition,
+        # check if we're in a member initializer list following a constructor.
+        if (
+            self.stack
+            and (
+                isinstance(self.stack[-1], _ConstructorInfo)
+                or isinstance(self.previous_stack_top, _ConstructorInfo)
             )
-            if access_match:
-                classinfo.access = access_match.group(2)
-
-                # Check that access keywords are indented +1 space.  Skip this
-                # check if the keywords are not preceded by whitespaces.
-                indent = access_match.group(1)
-                if len(indent) != classinfo.class_indent + 1 and re.match(r"^\s*$", indent):
-                    if classinfo.is_struct:
-                        parent = "struct " + classinfo.name
-                    else:
-                        parent = "class " + classinfo.name
-                    slots = ""
-                    if access_match.group(3):
-                        slots = access_match.group(3)
-                    error(
-                        filename,
-                        linenum,
-                        "whitespace/indent",
-                        3,
-                        f"{access_match.group(2)}{slots}:"
-                        f" should be indented +1 space inside {parent}",
-                    )
+            and not self.stack[-1].seen_open_brace
+            and re.search(r"[^:]:[^:]", line)
+        ):
+            self.stack.append(_MemInitListInfo(linenum, seen_open_brace=False))
 
         # Consume braces or semicolons from what's left of the line
         while True:
@@ -3532,34 +3598,42 @@ def Update(self, filename: str, clean_lines: CleansedLines, linenum: int, error)
 
             token = matched.group(1)
             if token == "{":
-                # If namespace or class hasn't seen a opening brace yet, mark
+                # If namespace or class hasn't seen an opening brace yet, mark
                 # namespace/class head as complete.  Push a new block onto the
                 # stack otherwise.
                 if not self.SeenOpenBrace():
+                    # End of initializer list wrap if present
+                    if isinstance(self.stack[-1], _MemInitListInfo):
+                        self._Pop()
                     self.stack[-1].seen_open_brace = True
                 elif re.match(r'^extern\s*"[^"]*"\s*\{', line):
                     self.stack.append(_ExternCInfo(linenum))
                 else:
                     self.stack.append(_BlockInfo(linenum, True))
                     if _MATCH_ASM.match(line):
                         self.stack[-1].inline_asm = _BLOCK_ASM
-
-            elif token in {";", ")"}:
+            elif token == ";":
                 # If we haven't seen an opening brace yet, but we already saw
                 # a semicolon, this is probably a forward declaration.  Pop
                 # the stack for these.
-                #
+                if not self.SeenOpenBrace():
+                    self._Pop()
+            elif token == ")":
                 # Similarly, if we haven't seen an opening brace yet, but we
                 # already saw a closing parenthesis, then these are probably
                 # function arguments with extra "class" or "struct" keywords.
                 # Also pop these stack for these.
-                if not self.SeenOpenBrace():
-                    self.stack.pop()
+                if (
+                    self.stack
+                    and not self.stack[-1].seen_open_brace
+                    and isinstance(self.stack[-1], _ClassInfo)
+                ):
+                    self._Pop()
             else:  # token == '}'
                 # Perform end of block checks and pop the stack.
                 if self.stack:
                     self.stack[-1].CheckEnd(filename, clean_lines, linenum, error)
-                    self.stack.pop()
+                    self._Pop()
             line = matched.group(2)
 
     def InnermostClass(self):
@@ -7097,11 +7171,11 @@ def CheckRedundantOverrideOrFinal(filename, clean_lines, linenum, error):
 
 # Returns true if we are at a new block, and it is directly
 # inside of a namespace.
-def IsBlockInNameSpace(nesting_state, is_forward_declaration):
+def IsBlockInNameSpace(nesting_state: NestingState, is_forward_declaration: bool):  # noqa: FBT001
     """Checks that the new block is directly in a namespace.
 
     Args:
-      nesting_state: The _NestingState object that contains info about our state.
+      nesting_state: The NestingState object that contains info about our state.
       is_forward_declaration: If the class is a forward declared class.
     Returns:
       Whether or not the new block is directly in a namespace.
@@ -7117,7 +7191,13 @@ def IsBlockInNameSpace(nesting_state, is_forward_declaration):
         if (
             len(nesting_state.stack) > 1
             and isinstance(nesting_state.previous_stack_top, _NamespaceInfo)
-            and isinstance(nesting_state.stack[-2], _NamespaceInfo)
+            and (
+                isinstance(nesting_state.stack[-2], _NamespaceInfo)
+                or len(nesting_state.stack) > 2  # Accommodate for WrappedInfo
+                and issubclass(type(nesting_state.stack[-1]), _WrappedInfo)
+                and not nesting_state.stack[-2].seen_open_brace
+                and isinstance(nesting_state.stack[-3], _NamespaceInfo)
+            )
         ):
             return True
     return False
@@ -7141,6 +7221,10 @@ def ShouldCheckNamespaceIndentation(
       only works for classes and namespaces inside of a namespace.
     """
 
+    # Required by all checks involving nesting_state
+    if not nesting_state.stack:
+        return False
+
     is_forward_declaration = IsForwardClassDeclaration(raw_lines_no_comments, linenum)
 
     if not (is_namespace_indent_item or is_forward_declaration):
@@ -7154,6 +7238,20 @@ def ShouldCheckNamespaceIndentation(
     if nesting_state.previous_stack_top and nesting_state.previous_open_parentheses > 0:
         return False
 
+    # Skip if we are extra-indenting a member initializer list.
+    if (
+        isinstance(nesting_state.previous_stack_top, _ConstructorInfo)  # F/N (A::A() : _a(0) {/{})
+        and (
+            isinstance(nesting_state.stack[-1], _MemInitListInfo)
+            or isinstance(nesting_state.popped_top, _MemInitListInfo)
+        )
+    ) or (  # popping constructor after MemInitList on the same line (: _a(a) {})
+        isinstance(nesting_state.previous_stack_top, _ConstructorInfo)
+        and isinstance(nesting_state.popped_top, _ConstructorInfo)
+        and re.search(r"[^:]:[^:]", raw_lines_no_comments[linenum])
+    ):
+        return False
+
     return IsBlockInNameSpace(nesting_state, is_forward_declaration)
 
 
diff --git a/cpplint_unittest.py b/cpplint_unittest.py
@@ -323,6 +323,54 @@ def testNamespaceIndentationIndentedParameter(self):
         results = self.GetNamespaceResults(lines)
         assert results == ""
 
+    def testNamespaceIndentationMemberInitializerList(self):
+        lines = [
+            "namespace Opossum {",
+            "",
+            "Acme::Acme(const std::shared_ptr<const AbstractOperator> left,",
+            "           const std::shared_ptr<const AbstractOperator> nigh)",
+            "    : _left(left), _behind(nigh) {}",
+            "",
+            "}  // namespace Opossum",
+        ]
+        assert self.GetNamespaceResults(lines) == ""
+
+        # Multiline member initializer List
+        lines = [
+            "namespace Rosenfield {",
+            "class Crush : public Habitual {",
+            " public:",
+            "  Crush() : _a(1),",
+            "            _b(2)",
+            "       {}",
+            "};",
+            "}  // namespace Rosenfield",
+        ]
+        assert self.GetNamespaceResults(lines) == ""
+
+        # Same line as constructor declaration
+        lines = [
+            "namespace Boucher {",
+            "   X::X() : _s(2) {}",
+            "   A::A() : _e(12) {",
+        ]
+        assert self.GetNamespaceResults(lines) == [
+            "Do not indent within a namespace.  [whitespace/indent_namespace] [4]",
+            "Do not indent within a namespace.  [whitespace/indent_namespace] [4]",
+        ]
+
+        # Definition on indented line
+        lines = [
+            "namespace Store {",
+            "",
+            "   Color::Color() : my_name_is('b')",
+            "       this_is_true(true) {",
+        ]
+        assert (
+            self.GetNamespaceResults(lines)
+            == "Do not indent within a namespace.  [whitespace/indent_namespace] [4]"
+        )
+
     def testNestingInNamespace(self):
         lines = [
             "namespace Test {",
diff --git a/samples/boost-sample/headers_inspect_exclude.def b/samples/boost-sample/headers_inspect_exclude.def
@@ -2,7 +2,7 @@
 1
 3
 Done processing src/inspect/unnamed_namespace_check.hpp
-Total errors found: 50
+Total errors found: 49
 
 src/inspect/unnamed_namespace_check.hpp:0:  No #ifndef header guard found, suggested CPP variable is: SAMPLES_BOOST_SAMPLE_SRC_INSPECT_UNNAMED_NAMESPACE_CHECK_HPP_  [build/header_guard] [5]
 src/inspect/unnamed_namespace_check.hpp:11:  Include the directory when naming header files  [build/include_subdir] [4]
@@ -18,7 +18,6 @@ src/inspect/unnamed_namespace_check.hpp:28:  Do not indent within a namespace.
 src/inspect/unnamed_namespace_check.hpp:28:  { should almost always be at the end of the previous line  [whitespace/braces] [4]
 src/inspect/unnamed_namespace_check.hpp:29:  Do not indent within a namespace.  [whitespace/indent_namespace] [4]
 src/inspect/unnamed_namespace_check.hpp:29:  Weird number of spaces at line-start.  Are you using a 2-space indent?  [whitespace/indent] [3]
-src/inspect/unnamed_namespace_check.hpp:30:  Do not indent within a namespace.  [whitespace/indent_namespace] [4]
 src/inspect/unnamed_namespace_check.hpp:30:  Weird number of spaces at line-start.  Are you using a 2-space indent?  [whitespace/indent] [3]
 src/inspect/unnamed_namespace_check.hpp:30:  { should almost always be at the end of the previous line  [whitespace/braces] [4]
 src/inspect/unnamed_namespace_check.hpp:31:  Extra space after ( in function call  [whitespace/parens] [4]
diff --git a/samples/protobuf-sample/simple.def b/samples/protobuf-sample/simple.def
diff --git a/samples/protobuf-sample/src/descriptor.pb.cc b/samples/protobuf-sample/src/descriptor.pb.cc

Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@`
`2`	`2`	`1`
`3`	`3`	`3`
`4`	`4`	`Done processing src/inspect/unnamed_namespace_check.hpp`
`5`		`-Total errors found: 50`
	`5`	`+Total errors found: 49`
`6`	`6`
`7`	`7`	`src/inspect/unnamed_namespace_check.hpp:0: No #ifndef header guard found, suggested CPP variable is: SAMPLES_BOOST_SAMPLE_SRC_INSPECT_UNNAMED_NAMESPACE_CHECK_HPP_ [build/header_guard] [5]`
`8`	`8`	`src/inspect/unnamed_namespace_check.hpp:11: Include the directory when naming header files [build/include_subdir] [4]`
`@@ -18,7 +18,6 @@ src/inspect/unnamed_namespace_check.hpp:28: Do not indent within a namespace.`
`18`	`18`	`src/inspect/unnamed_namespace_check.hpp:28: { should almost always be at the end of the previous line [whitespace/braces] [4]`
`19`	`19`	`src/inspect/unnamed_namespace_check.hpp:29: Do not indent within a namespace. [whitespace/indent_namespace] [4]`
`20`	`20`	`src/inspect/unnamed_namespace_check.hpp:29: Weird number of spaces at line-start. Are you using a 2-space indent? [whitespace/indent] [3]`
`21`		`-src/inspect/unnamed_namespace_check.hpp:30: Do not indent within a namespace. [whitespace/indent_namespace] [4]`
`22`	`21`	`src/inspect/unnamed_namespace_check.hpp:30: Weird number of spaces at line-start. Are you using a 2-space indent? [whitespace/indent] [3]`
`23`	`22`	`src/inspect/unnamed_namespace_check.hpp:30: { should almost always be at the end of the previous line [whitespace/braces] [4]`
`24`	`23`	`src/inspect/unnamed_namespace_check.hpp:31: Extra space after ( in function call [whitespace/parens] [4]`