STYLE: Fix script false positives for macros, member params, comments

Revert incorrect itk:: removals in four files that the script's
conservative heuristics should have protected:

- itkFlatStructuringElement.hxx: out-of-line member function params
  resolved in class scope (MSVC C2061 on Size<2>)
- itkEventObject.h: public macro must stay qualified for downstream use
- itkOpenCLUtil.h: Doxygen comment incorrectly modified
- itkGPUImageToImageFilter.hxx: out-of-line member function params

Fix three bugs in fix-redundant-namespace-qualifiers.py:
1. Block-comment tail: text before closing */ was processed as code
2. Multi-line macros: continuation lines (ending \) were not skipped
3. Out-of-line member function params: track paren depth so
   Class<T>::Method(itk::Foo) parameter lists are skipped

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: hjmjohnson

Modules/Core/Common/include/itkEventObject.h

@@ -142,14 +142,17 @@ operator<<(std::ostream & os, const EventObject & e)
   };                                                       \
   ITK_MACROEND_NOOP_STATEMENT
 
-#define itkEventMacroDefinition(classname, super)                                                                   \
-  classname::classname(const classname & s)                                                                         \
-    : super(s)                                                                                                      \
-  {}                                                                                                                \
-  classname::~classname() {}                                                                                        \
-  const char * classname::GetEventName() const { return #classname; }                                               \
-  bool classname::CheckEvent(const EventObject * e) const { return dynamic_cast<const classname *>(e) != nullptr; } \
-  EventObject * classname::MakeObject() const { return new classname; }                                             \
+#define itkEventMacroDefinition(classname, super)                            \
+  classname::classname(const classname & s)                                  \
+    : super(s)                                                               \
+  {}                                                                         \
+  classname::~classname() {}                                                 \
+  const char * classname::GetEventName() const { return #classname; }        \
+  bool         classname::CheckEvent(const itk::EventObject * e) const       \
+  {                                                                          \
+    return dynamic_cast<const classname *>(e) != nullptr;                    \
+  }                                                                          \
+  itk::EventObject * classname::MakeObject() const { return new classname; } \
   ITK_MACROEND_NOOP_STATEMENT
 
 #if !defined(ITK_LEGACY_REMOVE)

Modules/Core/GPUCommon/include/itkGPUImageToImageFilter.hxx

@@ -59,7 +59,7 @@ GPUImageToImageFilter<TInputImage, TOutputImage, TParentImageFilter>::GenerateDa
 template <typename TInputImage, typename TOutputImage, typename TParentImageFilter>
 void
 GPUImageToImageFilter<TInputImage, TOutputImage, TParentImageFilter>::GraftOutput(
-  typename GPUTraits<TOutputImage>::Type * output)
+  typename itk::GPUTraits<TOutputImage>::Type * output)
 {
   using GPUOutputImage = typename itk::GPUTraits<TOutputImage>::Type;
   typename GPUOutputImage::Pointer gpuImage = dynamic_cast<GPUOutputImage *>(this->GetOutput());
@@ -87,8 +87,8 @@ GPUImageToImageFilter<TInputImage, TOutputImage, TParentImageFilter>::GraftOutpu
 template <typename TInputImage, typename TOutputImage, typename TParentImageFilter>
 void
 GPUImageToImageFilter<TInputImage, TOutputImage, TParentImageFilter>::GraftOutput(
-  const DataObjectIdentifierType &         key,
-  typename GPUTraits<TOutputImage>::Type * output)
+  const DataObjectIdentifierType &              key,
+  typename itk::GPUTraits<TOutputImage>::Type * output)
 {
   using GPUOutputImage = typename itk::GPUTraits<TOutputImage>::Type;
   typename GPUOutputImage::Pointer gpuImage = dynamic_cast<GPUOutputImage *>(this->ProcessObject::GetOutput(key));

Modules/Core/GPUCommon/include/itkOpenCLUtil.h

@@ -96,7 +96,7 @@ void
 GetTypenameInString(const std::type_info & intype, std::ostringstream & ret);
 
 /** Get pixel dimension (number of channels).
- * For high-dimensional pixel format, only Vector< type, 2/3 > is acceptable. */
+ * For high-dimensional pixel format, only itk::Vector< type, 2/3 > is acceptable. */
 int
 GetPixelDimension(const std::type_info & intype);
 

Modules/Filtering/MathematicalMorphology/include/itkFlatStructuringElement.hxx

@@ -56,7 +56,9 @@ FlatStructuringElement<VDimension>::GeneratePolygon(TStructuringElement &, TRadi
 
 template <unsigned int VDimension>
 void
-FlatStructuringElement<VDimension>::GeneratePolygon(FlatStructuringElement<2> & res, Size<2> radius, unsigned int lines)
+FlatStructuringElement<VDimension>::GeneratePolygon(itk::FlatStructuringElement<2> & res,
+                                                    itk::Size<2>                     radius,
+                                                    unsigned int                     lines)
 {
   // radial decomposition method from "Radial Decomposition of Discs
   // and Spheres" - CVGIP: Graphical Models and Image Processing
@@ -126,7 +128,9 @@ FlatStructuringElement<VDimension>::GeneratePolygon(FlatStructuringElement<2> &
 
 template <unsigned int VDimension>
 void
-FlatStructuringElement<VDimension>::GeneratePolygon(FlatStructuringElement<3> & res, Size<3> radius, unsigned int lines)
+FlatStructuringElement<VDimension>::GeneratePolygon(itk::FlatStructuringElement<3> & res,
+                                                    itk::Size<3>                     radius,
+                                                    unsigned int                     lines)
 {
   res.SetRadius(radius);
   res.SetDecomposable(true);

Utilities/Maintenance/fix-redundant-namespace-qualifiers.py

@@ -86,6 +86,10 @@
 # Class/struct opening (to track class scope depth)
 _CLASS_RE = re.compile(r"\b(class|struct)\s+(\w+)")
 
+# Out-of-line member function definition: ClassName<...>::Method(
+# Parameters in these are resolved in class scope, not namespace scope.
+_OUTOFLINE_MEMBER_RE = re.compile(r"\w+\s*(?:<[^>]*>)?\s*::\s*(?:~?\w+)\s*\(")
+
 
 def _strip_comments_and_strings(line: str) -> str:
     """Return *line* with string literals and line-comments blanked out."""
@@ -116,35 +120,54 @@ def process_file(path: Path, *, fix: bool = False) -> list[tuple[int, str, str]]
     new_lines: list[str] = lines.copy()
 
     in_block_comment = False
+    in_macro = False  # Inside a multi-line #define (continuation with \)
+    # Track parenthesis depth and whether we're inside an out-of-line
+    # member function parameter list (where types resolve in class scope).
+    paren_depth = 0
+    in_member_params = False
 
     for i, line in enumerate(lines):
         # Track block comments
         if in_block_comment:
             end_pos = line.find("*/")
             if end_pos == -1:
                 continue
+            # Block comment closes on this line — blank everything up to
+            # and including the "*/", then continue processing the rest.
             in_block_comment = False
+            line_after_comment = " " * (end_pos + 2) + line[end_pos + 2 :]
+        else:
+            line_after_comment = line
 
-        # Check for block comment start
-        temp_line = line
+        # Check for block comment start and blank out comment regions
+        temp_line = line_after_comment
         while True:
             start = temp_line.find("/*")
             if start == -1:
                 break
             end = temp_line.find("*/", start + 2)
             if end == -1:
                 in_block_comment = True
+                # Blank from comment start to end of line
+                temp_line = temp_line[:start]
                 break
             temp_line = (
                 temp_line[:start] + " " * (end + 2 - start) + temp_line[end + 2 :]
             )
 
-        stripped = _strip_comments_and_strings(line)
-        if in_block_comment and "*/" not in line:
-            stripped = ""
+        stripped = _strip_comments_and_strings(temp_line)
+        if in_block_comment:
+            # Already blanked comment portion above; stripped has only code part
+            pass
 
-        # Skip preprocessor directives
+        # Skip preprocessor directives and multi-line macro bodies.
+        # Macro bodies (like #define itkEventMacroDefinition) use itk::
+        # that must remain qualified since macros expand at call site.
         if _PREPROCESSOR_RE.match(stripped):
+            in_macro = stripped.rstrip().endswith("\\")
+            continue
+        if in_macro:
+            in_macro = stripped.rstrip().endswith("\\")
             continue
 
         # Handle pending namespace (saw "namespace X" but no { yet)
@@ -205,6 +228,25 @@ def process_file(path: Path, *, fix: bool = False) -> list[tuple[int, str, str]]
         delta = _compute_brace_delta(stripped)
         brace_depth += delta
 
+        # Track parenthesis depth for out-of-line member function params.
+        # When paren_depth transitions 0→1 on a line with Class::Method(,
+        # mark that we're inside member function parameters.
+        # Save state before updating — the closing ) line is still part
+        # of the parameter list and should be protected.
+        currently_in_member_params = in_member_params
+        old_paren = paren_depth
+        paren_depth += stripped.count("(") - stripped.count(")")
+        if paren_depth < 0:
+            paren_depth = 0
+        if old_paren == 0 and paren_depth > 0:
+            # Entering a parenthesized expression — check if it's a
+            # member function definition (has ClassName::MethodName pattern)
+            if _OUTOFLINE_MEMBER_RE.search(stripped):
+                in_member_params = True
+                currently_in_member_params = True
+        if paren_depth == 0 and old_paren > 0:
+            in_member_params = False
+
         # Check if we left any namespace blocks
         while ns_stack and brace_depth < ns_stack[-1][1]:
             was_plain, _ = ns_stack.pop()
@@ -229,6 +271,13 @@ def process_file(path: Path, *, fix: bool = False) -> list[tuple[int, str, str]]
             if brace_depth > itk_ns_brace_depth:
                 continue
 
+            # Skip out-of-line member function parameter lists.
+            # In "Type Class<T>::Method(itk::Foo x)", the parameter types
+            # are resolved in the class scope, not namespace scope.
+            # Removing itk:: can cause lookup failures (e.g., MSVC C2061).
+            if currently_in_member_params:
+                continue
+
             # Find replaceable itk::Symbol occurrences
             has_replaceable = False
             for m in _ITK_QUAL_RE.finditer(stripped):