Merge branch 'main' into dependabot/pip/mypy-gte-1.10-and-lt-3

Author: tirth8205

CHANGELOG.md

@@ -18,6 +18,15 @@
 
 ### Fixed
 
+- Swift initializers, deinitializers and subscripts now emit `Function` nodes
+  (#786). `init_declaration`, `deinit_declaration` and `subscript_declaration`
+  are node types distinct from `function_declaration`, so the walker skipped
+  them and attributed the calls in their bodies to the enclosing *File* node —
+  a change inside one initializer read as file-wide blast radius, and
+  `get_impact_radius` on a callee could not trace back to the initializer that
+  calls it. Each is named after its declaration keyword, since the grammar
+  gives none of the three a usable name field (`subscript`'s would be its
+  return type, `deinit`'s is absent).
 - GitHub Copilot auto-detection now requires the Copilot extension and also
   recognizes the extension bundled with released VS Code installations.
 - C# methods with a non-generic return type are no longer named after that

code_review_graph/parser.py

@@ -752,6 +752,35 @@ class EdgeInfo:
     ".yaml": "yaml",
 }
 
+# ``.h`` is shared by C and C++. Keep C as the extension default, then promote
+# a header only when the C++ grammar finds syntax that C cannot express. Weak
+# compatibility markers such as ``__cplusplus`` and ``extern "C"`` are
+# deliberately excluded because they are common in otherwise-C headers.
+_CPP_HEADER_EVIDENCE_TYPES = frozenset({
+    "access_specifier",
+    "alias_declaration",
+    "base_class_clause",
+    "class_specifier",
+    "concept_definition",
+    "lambda_expression",
+    "namespace_definition",
+    "noexcept",
+    "template_declaration",
+    "trailing_return_type",
+    "using_declaration",
+})
+
+_CPP_HEADER_EVIDENCE_QUALIFIERS = frozenset({b"consteval", b"constinit"})
+
+_CPP_QT_STRUCTURAL_MACRO_REPLACEMENTS = {
+    b"QT_BEGIN_NAMESPACE": b" " * len(b"QT_BEGIN_NAMESPACE"),
+    b"QT_END_NAMESPACE": b" " * len(b"QT_END_NAMESPACE"),
+    b"Q_OBJECT": b" " * len(b"Q_OBJECT"),
+    b"Q_SIGNALS": b"public" + b" " * (len(b"Q_SIGNALS") - len(b"public")),
+    b"Q_SLOTS": b" " * len(b"Q_SLOTS"),
+    b"Q_EMIT": b" " * len(b"Q_EMIT"),
+}
+
 # Shebang interpreter → language mapping for extension-less Unix scripts.
 # Each key is the **basename** of the interpreter path as it appears after
 # ``#!`` (or after ``#!/usr/bin/env``).  Only languages already registered
@@ -943,13 +972,22 @@ class EdgeInfo:
     "rust": ["function_item", "function_signature_item"],
     "java": ["method_declaration", "constructor_declaration"],
     "c": ["function_definition"],
-    "cpp": ["function_definition"],
+    "cpp": ["function_definition", "declaration", "field_declaration"],
     "csharp": ["method_declaration", "constructor_declaration"],
     "ruby": ["method", "singleton_method"],
     "r": ["function_definition"],
     "perl": ["subroutine_declaration_statement", "method_declaration_statement"],
     "kotlin": ["function_declaration"],
-    "swift": ["function_declaration"],
+    # Swift: initializers, deinitializers and subscripts are separate node
+    # types, not `function_declaration`s, so they need listing alongside it —
+    # the same way java/csharp list `constructor_declaration`. Their names come
+    # from the `_get_name` Swift branch (the grammar has no usable name field).
+    "swift": [
+        "function_declaration",
+        "init_declaration",
+        "deinit_declaration",
+        "subscript_declaration",
+    ],
     "php": ["function_definition", "method_declaration"],
     "scala": ["function_definition", "function_declaration"],
     # Solidity: events and modifiers use kind="Function" because the graph
@@ -2522,6 +2560,22 @@ def parse_bytes(self, path: Path, source: bytes) -> tuple[list[NodeInfo], list[E
         if not language:
             return [], []
 
+        parser = None
+        tree = None
+        parse_source = source
+        if language == "c" and path.suffix.lower() == ".h":
+            cpp_parser = self._get_parser("cpp")
+            if cpp_parser is not None:
+                cpp_source = self._mask_cpp_qt_macros(source)
+                cpp_tree = cpp_parser.parse(cpp_source)
+                if self._has_cpp_header_evidence(cpp_tree.root_node):
+                    language = "cpp"
+                    parser = cpp_parser
+                    tree = cpp_tree
+                    parse_source = cpp_source
+        elif language == "cpp":
+            parse_source = self._mask_cpp_qt_macros(source)
+
         if language == "blade":
             return self._parse_blade(path, source)
 
@@ -2592,11 +2646,13 @@ def parse_bytes(self, path: Path, source: bytes) -> tuple[list[NodeInfo], list[E
         if language == "yaml":
             return [], []
 
-        parser = self._get_parser(language)
+        if parser is None:
+            parser = self._get_parser(language)
         if not parser:
             return [], []
 
-        tree = parser.parse(source)
+        if tree is None:
+            tree = parser.parse(parse_source)
         nodes: list[NodeInfo] = []
         edges: list[EdgeInfo] = []
         file_path_str = str(path)
@@ -2684,6 +2740,140 @@ def parse_bytes(self, path: Path, source: bytes) -> tuple[list[NodeInfo], list[E
 
         return nodes, edges
 
+    @staticmethod
+    def _has_cpp_header_evidence(root) -> bool:
+        """Return whether a parsed ``.h`` tree contains C++-only syntax."""
+        pending = [root]
+        while pending:
+            node = pending.pop()
+            if node.type == "ERROR" or _is_in_static_dead_guard(node):
+                continue
+
+            previous = node.prev_named_sibling
+            recovered_after_error = (
+                previous is not None
+                and previous.type == "ERROR"
+                and previous.end_byte == node.start_byte
+            )
+            if recovered_after_error:
+                continue
+
+            if node.type in _CPP_HEADER_EVIDENCE_TYPES:
+                return True
+            if (
+                node.type == "enum_specifier"
+                and any(child.type in ("class", "struct") for child in node.children)
+            ):
+                return True
+            if (
+                node.type == "type_qualifier"
+                and node.text in _CPP_HEADER_EVIDENCE_QUALIFIERS
+            ):
+                return True
+            pending.extend(node.named_children)
+        return False
+
+    @staticmethod
+    def _mask_cpp_qt_macros(source: bytes) -> bytes:
+        """Shield structural Qt macros without changing byte or line offsets."""
+        masked = bytearray(source)
+        length = len(source)
+        index = 0
+        line_has_code = False
+
+        def skip_quoted(start: int, quote: int) -> int:
+            cursor = start + 1
+            while cursor < length:
+                if source[cursor] == ord("\\"):
+                    cursor += 2
+                elif source[cursor] == quote:
+                    return cursor + 1
+                else:
+                    cursor += 1
+            return length
+
+        def raw_string_end(start: int) -> Optional[int]:
+            for prefix in (b'u8R"', b'LR"', b'UR"', b'uR"', b'R"'):
+                if not source.startswith(prefix, start):
+                    continue
+                delimiter_start = start + len(prefix)
+                opening = source.find(b"(", delimiter_start, delimiter_start + 17)
+                if opening == -1:
+                    return None
+                delimiter = source[delimiter_start:opening]
+                if any(byte in b" ()\\\t\r\n" for byte in delimiter):
+                    return None
+                closing = source.find(b")" + delimiter + b'"', opening + 1)
+                return length if closing == -1 else closing + len(delimiter) + 2
+            return None
+
+        while index < length:
+            byte = source[index]
+            if byte == ord("\n"):
+                line_has_code = False
+                index += 1
+                continue
+
+            if source.startswith(b"//", index):
+                newline = source.find(b"\n", index + 2)
+                index = length if newline == -1 else newline
+                continue
+            if source.startswith(b"/*", index):
+                closing = source.find(b"*/", index + 2)
+                comment_end = length if closing == -1 else closing + 2
+                if b"\n" in source[index:comment_end]:
+                    line_has_code = False
+                index = comment_end
+                continue
+
+            if byte == ord("#") and not line_has_code:
+                cursor = index
+                while cursor < length:
+                    newline = source.find(b"\n", cursor)
+                    if newline == -1:
+                        cursor = length
+                        break
+                    previous = newline - 1
+                    if previous >= cursor and source[previous] == ord("\r"):
+                        previous -= 1
+                    if previous < cursor or source[previous] != ord("\\"):
+                        cursor = newline
+                        break
+                    cursor = newline + 1
+                index = cursor
+                continue
+
+            raw_end = raw_string_end(index)
+            if raw_end is not None:
+                line_has_code = True
+                index = raw_end
+                continue
+            if byte in (ord('"'), ord("'")):
+                line_has_code = True
+                index = skip_quoted(index, byte)
+                continue
+
+            if byte == ord("_") or chr(byte).isalpha():
+                end = index + 1
+                while end < length:
+                    candidate = source[end]
+                    if candidate != ord("_") and not chr(candidate).isalnum():
+                        break
+                    end += 1
+                token = source[index:end]
+                replacement = _CPP_QT_STRUCTURAL_MACRO_REPLACEMENTS.get(token)
+                if replacement is not None:
+                    masked[index:end] = replacement
+                line_has_code = True
+                index = end
+                continue
+
+            if byte not in b" \t\v\f\r":
+                line_has_code = True
+            index += 1
+
+        return bytes(masked)
+
     @classmethod
     def _mask_blade_comments(cls, text: str) -> str:
         """Mask Blade comments while preserving offsets and line numbers."""
@@ -14064,6 +14254,13 @@ def _get_name(self, node, language: str, kind: str) -> Optional[str]:
 
         if language == "cpp" and kind == "function":
             declarator = node.child_by_field_name("declarator")
+            if node.type in ("declaration", "field_declaration"):
+                if (
+                    not self._cpp_declaration_has_callable_scope(node)
+                    or not self._cpp_is_callable_declaration(declarator)
+                ):
+                    return None
+                return self._cpp_callable_name(declarator)
             cpp_name = self._cpp_callable_name(declarator)
             if cpp_name:
                 return cpp_name
@@ -14157,6 +14354,18 @@ def _leaf_name(qi):
             for child in node.children:
                 if child.type == "identifier":
                     return child.text.decode("utf-8", errors="replace")
+        # Swift init/deinit/subscript: the grammar gives none of them a usable
+        # name. `init_declaration`'s name field is the `init` keyword itself,
+        # `deinit_declaration` has no name field at all (so the generic loop
+        # returns None and the node is dropped), and `subscript_declaration`'s
+        # name field is the *return type* (`subscript(i: Int) -> String` would
+        # be named "String"). Name each after its Swift declaration keyword.
+        if language == "swift" and node.type in (
+            "init_declaration",
+            "deinit_declaration",
+            "subscript_declaration",
+        ):
+            return node.type.removesuffix("_declaration")
         # Swift extensions: name is inside user_type > type_identifier
         # (e.g. `extension MyClass: Protocol { ... }`)
         if language == "swift" and node.type == "class_declaration":
@@ -14426,6 +14635,11 @@ def _cpp_find_function_declarator(self, declarator):
         if declarator is None:
             return None
         if declarator.type in ("function_declarator", "abstract_function_declarator"):
+            nested = self._cpp_find_function_declarator(
+                declarator.child_by_field_name("declarator"),
+            )
+            if nested is not None:
+                return nested
             return declarator
         for child in declarator.named_children:
             if child.type in ("parameter_list", "template_argument_list"):
@@ -14435,6 +14649,44 @@ def _cpp_find_function_declarator(self, declarator):
                 return found
         return None
 
+    def _cpp_is_callable_declaration(self, declarator) -> bool:
+        """Return whether a declaration names a function, not a function pointer."""
+        function_declarator = self._cpp_find_function_declarator(declarator)
+        if function_declarator is None:
+            return False
+
+        callable_declarator = function_declarator.child_by_field_name("declarator")
+        if (
+            callable_declarator is None
+            or callable_declarator.type != "parenthesized_declarator"
+        ):
+            return True
+
+        # ``void (*callback)(int)`` has no nested function declarator inside
+        # the parentheses.  A real function returning a function pointer,
+        # such as ``void (*factory())(int)``, does.
+        return self._cpp_find_function_declarator(callable_declarator) is not None
+
+    @staticmethod
+    def _cpp_declaration_has_callable_scope(declaration) -> bool:
+        """Limit callable declarations to file, namespace, and class scopes."""
+        scope = declaration.parent
+        while scope is not None:
+            if scope.type in (
+                "translation_unit",
+                "namespace_definition",
+                "field_declaration_list",
+            ):
+                return not _is_in_static_dead_guard(declaration)
+            if scope.type in (
+                "compound_statement",
+                "function_definition",
+                "lambda_expression",
+            ):
+                return False
+            scope = scope.parent
+        return False
+
     def _cpp_find_qualified_identifier(self, declarator):
         """Find the callable's qualified identifier outside its parameters."""
         if declarator is None:

tests/fixtures/cpp_qt_headers/MyWidget.cpp

@@ -0,0 +1,12 @@
+#include "MyWidget.h"
+
+MyWidget::MyWidget(QWidget* parent) : QMainWindow(parent) {}
+MyWidget::~MyWidget() {}
+void MyWidget::doSomething() { onReset(); }
+int MyWidget::calculateValue(int a, int b) { return a + b; }
+void MyWidget::onButtonClicked() { Q_EMIT dataReady(calculateValue(1, 2)); }
+void MyWidget::onDataReceived(int value) {
+  if (value < 0) { Q_EMIT errorOccurred("err"); return; }
+  doSomething();
+}
+void MyWidget::onReset() { Q_EMIT dataReady(0); }

tests/fixtures/cpp_qt_headers/MyWidget.h

@@ -0,0 +1,26 @@
+#pragma once
+#include <QMainWindow>
+
+QT_BEGIN_NAMESPACE namespace Ui { class MyWidgetClass; };
+QT_END_NAMESPACE
+
+class MyWidget : public QMainWindow {
+  Q_OBJECT
+
+ public:
+  MyWidget(QWidget* parent = nullptr);
+  ~MyWidget();
+  void doSomething();
+  int calculateValue(int a, int b);
+
+ protected Q_SLOTS:
+  void onButtonClicked();
+  void onDataReceived(int value);
+
+ public Q_SLOTS:
+  void onReset();
+
+ Q_SIGNALS:
+  void dataReady(int result);
+  void errorOccurred(const QString& msg);
+};

tests/fixtures/cpp_qt_headers/MyWidgetPlain.cpp

@@ -0,0 +1,10 @@
+#include "MyWidgetPlain.h"
+
+MyWidgetPlain::MyWidgetPlain() {}
+MyWidgetPlain::~MyWidgetPlain() {}
+
+void MyWidgetPlain::doSomething() { onReset(); }
+int MyWidgetPlain::calculateValue(int a, int b) { return a + b; }
+void MyWidgetPlain::onButtonClicked() { int result = calculateValue(1, 2); }
+void MyWidgetPlain::onDataReceived(int value) { if (value < 0) return; doSomething(); }
+void MyWidgetPlain::onReset() {}