mirror of
https://github.com/facebook/react-native.git
synced 2026-11-18 20:19:07 +00:00
Reorganize utils and add generalize type string parsing (#55698)
Summary: Pull Request resolved: https://github.com/facebook/react-native/pull/55698 Changelog: [Internal] Refactors utils.py into a proper package structure and adds comprehensive argument string parsing utilities. - Converts utils.py to utils/ package with submodules - Adds argument_parsing.py with parse_arg_string() and related utilities - Adds qualified_path.py with parse_qualified_path moved from old utils.py - Renames test_member.py to test_parse_arg_string.py with updated tests for the new 4-tuple Argument format Reviewed By: cipolleschi Differential Revision: D94077819 fbshipit-source-id: 460d7a44e6d3e55580d996877ca63fa0c777bc23
This commit is contained in:
1 parent
5993308a88
commit
357dd6b3ec
7 files changed
+752
-520
No files matched your search
@@ -4,7 +4,6 @@
|
||||
# LICENSE file in the root directory of this source tree.
|
||||
|
||||
from .main import build_snapshot
|
||||
from .member import FunctionMember, FunctionModifiers
|
||||
from .path_utils import get_repo_root
|
||||
|
||||
__all__ = ["build_snapshot", "FunctionMember", "FunctionModifiers", "get_repo_root"]
|
||||
__all__ = ["build_snapshot", "get_repo_root"]
|
||||
@@ -5,12 +5,18 @@
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import re
|
||||
from abc import ABC, abstractmethod
|
||||
from dataclasses import dataclass
|
||||
from typing import TYPE_CHECKING
|
||||
|
||||
from .template import Template, TemplateList
|
||||
from .utils import (
|
||||
Argument,
|
||||
format_arguments,
|
||||
format_parsed_type,
|
||||
parse_arg_string,
|
||||
parse_function_pointer_argstring,
|
||||
parse_type_with_argstrings,
|
||||
)
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from .scope import Scope
|
||||
@@ -90,6 +96,10 @@ class VariableMember(Member):
|
||||
self.is_mutable: bool = is_mutable
|
||||
self.definition: str = definition
|
||||
self.argstring: str | None = argstring
|
||||
self._fp_arguments: list[Argument] = (
|
||||
parse_function_pointer_argstring(argstring) if argstring else []
|
||||
)
|
||||
self._parsed_type: list[str | list[Argument]] = parse_type_with_argstrings(type)
|
||||
|
||||
def close(self, scope: Scope):
|
||||
# TODO: handle unqualified references
|
||||
@@ -125,15 +135,17 @@ class VariableMember(Member):
|
||||
result += "mutable "
|
||||
|
||||
if self._is_function_pointer():
|
||||
formatted_args = format_arguments(self._fp_arguments)
|
||||
qualified_type = format_parsed_type(self._parsed_type)
|
||||
# Function pointer types: argstring is ")(args...)"
|
||||
# If type already contains "(*", e.g. "void *(*" or "void(*", use directly
|
||||
# Otherwise add "(*" to form proper function pointer syntax
|
||||
if "(*" in self.type:
|
||||
result += f"{self.type}{name}{self.argstring}"
|
||||
if "(*" in qualified_type:
|
||||
result += f"{qualified_type}{name})({formatted_args})"
|
||||
else:
|
||||
result += f"{self.type} (*{name}{self.argstring}"
|
||||
result += f"{qualified_type} (*{name})({formatted_args})"
|
||||
else:
|
||||
result += f"{self.type} {name}"
|
||||
result += f"{format_parsed_type(self._parsed_type)} {name}"
|
||||
|
||||
if self.value is not None and (self.is_const or self.is_constexpr):
|
||||
result += f" = {self.value}"
|
||||
@@ -143,32 +155,6 @@ class VariableMember(Member):
|
||||
return result
|
||||
|
||||
|
||||
@dataclass
|
||||
class FunctionModifiers:
|
||||
"""Parsed function modifiers that appear after the parameter list."""
|
||||
|
||||
is_const: bool = False
|
||||
is_override: bool = False
|
||||
is_final: bool = False
|
||||
is_noexcept: bool = False
|
||||
noexcept_expr: str | None = None
|
||||
is_pure_virtual: bool = False
|
||||
is_default: bool = False
|
||||
is_delete: bool = False
|
||||
|
||||
|
||||
# Pattern for function pointer / pointer to member / reference to array:
|
||||
# Matches: (*name), (Class::*name), (&name), (*name)[N]
|
||||
# Group 1: the identifier name
|
||||
_FUNC_PTR_PATTERN = re.compile(
|
||||
r"\(\s*" # Opening paren
|
||||
r"(?:[a-zA-Z_][a-zA-Z0-9_]*\s*::\s*)?" # Optional Class::
|
||||
r"[*&]\s*" # * or &
|
||||
r"([a-zA-Z_][a-zA-Z0-9_]*)" # Capture: identifier name
|
||||
r"\s*\)" # Closing paren
|
||||
)
|
||||
|
||||
|
||||
class FunctionMember(Member):
|
||||
def __init__(
|
||||
self,
|
||||
@@ -178,12 +164,16 @@ class FunctionMember(Member):
|
||||
arg_string: str,
|
||||
is_virtual: bool,
|
||||
is_static: bool,
|
||||
doxygen_params: list[Argument] | None = None,
|
||||
) -> None:
|
||||
super().__init__(name, visibility)
|
||||
self.type: str = type
|
||||
self.is_virtual: bool = is_virtual
|
||||
self.is_static: bool = is_static
|
||||
self.arguments, self.modifiers = FunctionMember.parse_arg_string(arg_string)
|
||||
parsed_arguments, self.modifiers = parse_arg_string(arg_string)
|
||||
self.arguments = (
|
||||
doxygen_params if doxygen_params is not None else parsed_arguments
|
||||
)
|
||||
|
||||
self.is_const = self.modifiers.is_const
|
||||
self.is_override = self.modifiers.is_override
|
||||
@@ -218,19 +208,7 @@ class FunctionMember(Member):
|
||||
if self.type:
|
||||
result += f"{self.type} "
|
||||
|
||||
result += f"{name}("
|
||||
|
||||
for i, (arg_type, arg_name, arg_default) in enumerate(self.arguments):
|
||||
if arg_name:
|
||||
result += f"{arg_type} {arg_name}"
|
||||
else:
|
||||
result += arg_type
|
||||
if arg_default:
|
||||
result += f" = {arg_default}"
|
||||
if i < len(self.arguments) - 1:
|
||||
result += ", "
|
||||
|
||||
result += ")"
|
||||
result += f"{name}({format_arguments(self.arguments)})"
|
||||
|
||||
if self.modifiers.is_const:
|
||||
result += " const"
|
||||
@@ -257,325 +235,25 @@ class FunctionMember(Member):
|
||||
result += ";"
|
||||
return result
|
||||
|
||||
@staticmethod
|
||||
def _find_matching_paren(s: str, start: int = 0) -> int:
|
||||
"""Find the index of the closing parenthesis matching the opening one at start.
|
||||
|
||||
Handles nested parentheses and angle brackets (for templates).
|
||||
Returns -1 if no matching parenthesis is found.
|
||||
"""
|
||||
if start >= len(s) or s[start] != "(":
|
||||
return -1
|
||||
|
||||
depth = 0
|
||||
angle_depth = 0
|
||||
i = start
|
||||
|
||||
while i < len(s):
|
||||
c = s[i]
|
||||
if c == "<":
|
||||
angle_depth += 1
|
||||
elif c == ">":
|
||||
angle_depth -= 1
|
||||
elif c == "(":
|
||||
depth += 1
|
||||
elif c == ")":
|
||||
depth -= 1
|
||||
if depth == 0:
|
||||
return i
|
||||
i += 1
|
||||
|
||||
return -1
|
||||
|
||||
@staticmethod
|
||||
def _find_matching_angle(s: str, start: int = 0) -> int:
|
||||
"""Find the index of the closing angle bracket matching the opening one at start.
|
||||
|
||||
Handles nested angle brackets and parentheses.
|
||||
Returns -1 if no matching bracket is found.
|
||||
"""
|
||||
if start >= len(s) or s[start] != "<":
|
||||
return -1
|
||||
|
||||
depth = 0
|
||||
paren_depth = 0
|
||||
i = start
|
||||
|
||||
while i < len(s):
|
||||
c = s[i]
|
||||
if c == "(":
|
||||
paren_depth += 1
|
||||
elif c == ")":
|
||||
paren_depth -= 1
|
||||
elif c == "<" and paren_depth == 0:
|
||||
depth += 1
|
||||
elif c == ">" and paren_depth == 0:
|
||||
depth -= 1
|
||||
if depth == 0:
|
||||
return i
|
||||
i += 1
|
||||
|
||||
return -1
|
||||
|
||||
@staticmethod
|
||||
def _split_arguments(args_str: str) -> list[str]:
|
||||
"""Split arguments by comma, respecting nested structures.
|
||||
|
||||
Handles:
|
||||
- Nested parentheses: std::function<int(int, int)>
|
||||
- Nested angle brackets: std::map<K, V>
|
||||
- Brace initializers: std::vector<int> v = {1, 2, 3}
|
||||
"""
|
||||
result = []
|
||||
current = []
|
||||
paren_depth = 0
|
||||
angle_depth = 0
|
||||
brace_depth = 0
|
||||
|
||||
for c in args_str:
|
||||
if c == "<":
|
||||
angle_depth += 1
|
||||
elif c == ">":
|
||||
angle_depth = max(0, angle_depth - 1)
|
||||
elif c == "(":
|
||||
paren_depth += 1
|
||||
elif c == ")":
|
||||
paren_depth = max(0, paren_depth - 1)
|
||||
elif c == "{":
|
||||
brace_depth += 1
|
||||
elif c == "}":
|
||||
brace_depth = max(0, brace_depth - 1)
|
||||
elif (
|
||||
c == "," and paren_depth == 0 and angle_depth == 0 and brace_depth == 0
|
||||
):
|
||||
result.append("".join(current).strip())
|
||||
current = []
|
||||
continue
|
||||
current.append(c)
|
||||
|
||||
if current:
|
||||
result.append("".join(current).strip())
|
||||
|
||||
return [arg for arg in result if arg]
|
||||
|
||||
# C++ reserved keywords that serve as type qualifiers/specifiers.
|
||||
# When ALL tokens in the prefix (everything before the last token) are
|
||||
# from this set, the last token must be part of the type, not a name.
|
||||
# Primitive type names (int, bool, char, etc.) are intentionally excluded
|
||||
# to avoid ambiguity with common named params like "int x" or "bool flag".
|
||||
_CPP_TYPE_QUALIFIERS = frozenset(
|
||||
{
|
||||
"const",
|
||||
"volatile",
|
||||
"mutable",
|
||||
"unsigned",
|
||||
"signed",
|
||||
"long",
|
||||
"short",
|
||||
}
|
||||
)
|
||||
|
||||
@staticmethod
|
||||
def _prefix_is_all_qualifiers(prefix: str) -> bool:
|
||||
"""Check if all tokens in the prefix are type qualifiers/specifiers.
|
||||
|
||||
When the prefix consists entirely of reserved qualifiers (e.g., "const",
|
||||
"const unsigned"), the following token cannot be a parameter name — it
|
||||
must be completing the type.
|
||||
"""
|
||||
return all(t in FunctionMember._CPP_TYPE_QUALIFIERS for t in prefix.split())
|
||||
|
||||
@staticmethod
|
||||
def _looks_like_type_token(token: str) -> bool:
|
||||
"""Check if a token ends with type-related punctuation.
|
||||
|
||||
Returns True if the token ends with pointer, reference, template closer,
|
||||
or array bracket — indicating it's part of a type, not a name.
|
||||
"""
|
||||
return (
|
||||
token.endswith("*")
|
||||
or token.endswith("&")
|
||||
or token.endswith(">")
|
||||
or token.endswith("]")
|
||||
)
|
||||
|
||||
@staticmethod
|
||||
def _parse_single_argument(arg: str) -> tuple[str, str, str | None]:
|
||||
"""Parse a single C++ argument into (type, name, default_value).
|
||||
|
||||
Handles complex cases:
|
||||
- Regular: "int x" -> ("int", "x", None)
|
||||
- With default: "int x = 5" -> ("int", "x", "5")
|
||||
- Function pointer: "int (*callback)(int, int)" -> ("int (*)(int, int)", "callback", None)
|
||||
- Pointer to member: "void (Class::*method)()" -> ("void (Class::*)()", "method", None)
|
||||
- Reference to array: "int (&arr)[10]" -> ("int (&)[10]", "arr", None)
|
||||
- No name (void): "void" -> ("void", "", None)
|
||||
- Unnamed multi-token: "const bool" -> ("const bool", "", None)
|
||||
"""
|
||||
arg = arg.strip()
|
||||
if not arg:
|
||||
return ("", "", None)
|
||||
|
||||
default_value: str | None = None
|
||||
base_arg = arg
|
||||
|
||||
# Handle default values: split on '=' but respect nested structures
|
||||
eq_pos = FunctionMember._find_default_value_start(arg)
|
||||
if eq_pos != -1:
|
||||
base_arg = arg[:eq_pos].strip()
|
||||
default_value = arg[eq_pos + 1 :].strip()
|
||||
|
||||
# Try to match function pointer / pointer to member / reference to array pattern
|
||||
match = _FUNC_PTR_PATTERN.search(base_arg)
|
||||
if match:
|
||||
name = match.group(1)
|
||||
# Reconstruct type by removing the name from the pattern
|
||||
type_str = base_arg[: match.start(1)] + base_arg[match.end(1) :]
|
||||
return (type_str.strip(), name, default_value)
|
||||
|
||||
# Regular case: last token is the name
|
||||
parts = base_arg.rsplit(None, 1)
|
||||
if len(parts) == 2:
|
||||
prefix, potential_name = parts
|
||||
if FunctionMember._looks_like_type_token(
|
||||
potential_name
|
||||
) or FunctionMember._prefix_is_all_qualifiers(prefix):
|
||||
return (base_arg, "", default_value)
|
||||
return (prefix, potential_name, default_value)
|
||||
else:
|
||||
return (base_arg, "", default_value)
|
||||
|
||||
@staticmethod
|
||||
def _find_default_value_start(arg: str) -> int:
|
||||
"""Find the position of '=' that starts a default value.
|
||||
|
||||
Returns -1 if no default value found.
|
||||
Ignores '=' inside nested structures like templates or lambdas.
|
||||
"""
|
||||
paren_depth = 0
|
||||
angle_depth = 0
|
||||
brace_depth = 0
|
||||
|
||||
i = 0
|
||||
while i < len(arg):
|
||||
c = arg[i]
|
||||
if c == "<":
|
||||
angle_depth += 1
|
||||
elif c == ">":
|
||||
angle_depth = max(0, angle_depth - 1)
|
||||
elif c == "(":
|
||||
paren_depth += 1
|
||||
elif c == ")":
|
||||
paren_depth = max(0, paren_depth - 1)
|
||||
elif c == "{":
|
||||
brace_depth += 1
|
||||
elif c == "}":
|
||||
brace_depth = max(0, brace_depth - 1)
|
||||
elif (
|
||||
c == "=" and paren_depth == 0 and angle_depth == 0 and brace_depth == 0
|
||||
):
|
||||
return i
|
||||
i += 1
|
||||
|
||||
return -1
|
||||
|
||||
@staticmethod
|
||||
def _parse_modifiers(modifiers_str: str) -> FunctionModifiers:
|
||||
"""Parse function modifiers after the parameter list.
|
||||
|
||||
Handles: const, override, final, noexcept, noexcept(expr), = 0, = default, = delete
|
||||
"""
|
||||
result = FunctionModifiers()
|
||||
s = modifiers_str.strip()
|
||||
|
||||
# Handle = 0, = default, = delete
|
||||
eq_match = re.search(r"=\s*(0|default|delete)\s*$", s)
|
||||
if eq_match:
|
||||
value = eq_match.group(1)
|
||||
if value == "0":
|
||||
result.is_pure_virtual = True
|
||||
elif value == "default":
|
||||
result.is_default = True
|
||||
elif value == "delete":
|
||||
result.is_delete = True
|
||||
s = s[: eq_match.start()].strip()
|
||||
|
||||
# Handle noexcept with optional expression
|
||||
noexcept_match = re.search(r"\bnoexcept\b", s)
|
||||
if noexcept_match:
|
||||
result.is_noexcept = True
|
||||
# Check for noexcept(expr)
|
||||
rest = s[noexcept_match.end() :]
|
||||
rest_stripped = rest.lstrip()
|
||||
if rest_stripped.startswith("("):
|
||||
paren_end = FunctionMember._find_matching_paren(rest_stripped, 0)
|
||||
if paren_end != -1:
|
||||
result.noexcept_expr = rest_stripped[1:paren_end].strip()
|
||||
# Remove noexcept and its expression from the string for further parsing
|
||||
s = s[: noexcept_match.start()] + s[noexcept_match.end() :]
|
||||
if result.noexcept_expr:
|
||||
# Also remove the (expr) part
|
||||
s = re.sub(r"\([^)]*\)", "", s, count=1)
|
||||
|
||||
# Parse remaining tokens
|
||||
tokens = s.split()
|
||||
for token in tokens:
|
||||
if token == "const":
|
||||
result.is_const = True
|
||||
elif token == "override":
|
||||
result.is_override = True
|
||||
elif token == "final":
|
||||
result.is_final = True
|
||||
|
||||
return result
|
||||
|
||||
@staticmethod
|
||||
def parse_arg_string(
|
||||
arg_string: str,
|
||||
) -> tuple[list[tuple[str, str, str | None]], FunctionModifiers]:
|
||||
"""Parse a C++ function argument string.
|
||||
|
||||
Args:
|
||||
arg_string: String in format "(type1 arg1, type2 arg2 = default) [modifiers]"
|
||||
|
||||
Returns:
|
||||
Tuple of (arguments, modifiers) where:
|
||||
- arguments: list of (type, name, default_value) tuples
|
||||
- modifiers: FunctionModifiers dataclass with parsed modifier flags
|
||||
"""
|
||||
arg_string = arg_string.strip()
|
||||
|
||||
if not arg_string.startswith("("):
|
||||
return ([], FunctionModifiers())
|
||||
|
||||
close_paren = FunctionMember._find_matching_paren(arg_string, 0)
|
||||
if close_paren == -1:
|
||||
return ([], FunctionModifiers())
|
||||
|
||||
args_content = arg_string[1:close_paren].strip()
|
||||
modifiers_str = arg_string[close_paren + 1 :]
|
||||
|
||||
arguments: list[tuple[str, str, str | None]] = []
|
||||
if args_content:
|
||||
for arg in FunctionMember._split_arguments(args_content):
|
||||
parsed = FunctionMember._parse_single_argument(arg)
|
||||
if parsed[0] or parsed[1]:
|
||||
arguments.append(parsed)
|
||||
|
||||
modifiers = FunctionMember._parse_modifiers(modifiers_str)
|
||||
|
||||
return (arguments, modifiers)
|
||||
|
||||
|
||||
class TypedefMember(Member):
|
||||
def __init__(
|
||||
self, name: str, type: str, argstring: str | None, visibility: str, keyword: str
|
||||
) -> None:
|
||||
super().__init__(name, visibility)
|
||||
self.type: str = type
|
||||
self.keyword: str = keyword
|
||||
self.argstring: str | None = argstring
|
||||
|
||||
# Parse function pointer argstrings (e.g. ")(int x, float y)")
|
||||
self._fp_arguments: list[Argument] = (
|
||||
parse_function_pointer_argstring(argstring) if argstring else []
|
||||
)
|
||||
|
||||
# Parse inline function signatures in the type so that argument
|
||||
# lists are stored as structured data, not raw strings.
|
||||
self._parsed_type: list[str | list[Argument]] = parse_type_with_argstrings(type)
|
||||
self.type: str = type
|
||||
|
||||
def close(self, scope: Scope):
|
||||
# TODO: handle unqualified references
|
||||
pass
|
||||
@@ -602,14 +280,16 @@ class TypedefMember(Member):
|
||||
result += self.keyword
|
||||
|
||||
if self.keyword == "using":
|
||||
result += f" {name} = {self.type};"
|
||||
result += f" {name} = {format_parsed_type(self._parsed_type)};"
|
||||
elif self._is_function_pointer():
|
||||
formatted_args = format_arguments(self._fp_arguments)
|
||||
qualified_type = format_parsed_type(self._parsed_type)
|
||||
# Function pointer typedef: "typedef return_type (*name)(args);"
|
||||
# type is e.g. "void(*", argstring is ")(args...)"
|
||||
if "(*" in self.type:
|
||||
result += f" {self.type}{name}{self.argstring};"
|
||||
if "(*" in qualified_type:
|
||||
result += f" {qualified_type}{name})({formatted_args});"
|
||||
else:
|
||||
result += f" {self.type}(*{name}{self.argstring};"
|
||||
result += f" {qualified_type}(*{name})({formatted_args});"
|
||||
else:
|
||||
result += f" {self.type} {name};"
|
||||
|
||||
|
||||
@@ -1,63 +0,0 @@
|
||||
# Copyright (c) Meta Platforms, Inc. and affiliates.
|
||||
#
|
||||
# This source code is licensed under the MIT license found in the
|
||||
# LICENSE file in the root directory of this source tree.
|
||||
|
||||
|
||||
def parse_qualified_path(path: str) -> list[str]:
|
||||
"""
|
||||
Parse a qualified path into a list of names.
|
||||
|
||||
Handles template syntax correctly by not splitting on "::" inside
|
||||
angle brackets. For example:
|
||||
- "std::vector<std::string>::test" -> ["std", "vector<std::string>", "test"]
|
||||
- "ns::Foo<A, B>::Bar" -> ["ns", "Foo<A, B>", "Bar"]
|
||||
|
||||
Also handles edge cases:
|
||||
- Comparison operators inside parentheses: "std::enable_if<(N > 0)>::type"
|
||||
- Arrow operators: "decltype(ptr->member)::type"
|
||||
- Bitshift operators: "std::integral_constant<int, (1 >> 2)>::value"
|
||||
"""
|
||||
result = []
|
||||
current = ""
|
||||
angle_depth = 0
|
||||
paren_depth = 0
|
||||
i = 0
|
||||
|
||||
while i < len(path):
|
||||
char = path[i]
|
||||
|
||||
if char == "(":
|
||||
paren_depth += 1
|
||||
current += char
|
||||
i += 1
|
||||
elif char == ")":
|
||||
paren_depth -= 1
|
||||
current += char
|
||||
i += 1
|
||||
elif char == "<" and paren_depth == 0:
|
||||
angle_depth += 1
|
||||
current += char
|
||||
i += 1
|
||||
elif char == ">" and paren_depth == 0:
|
||||
# Check for arrow operator "->" which should not affect angle_depth
|
||||
if i > 0 and path[i - 1] == "-":
|
||||
current += char
|
||||
i += 1
|
||||
else:
|
||||
angle_depth -= 1
|
||||
current += char
|
||||
i += 1
|
||||
elif path[i : i + 2] == "::" and angle_depth == 0 and paren_depth == 0:
|
||||
if current:
|
||||
result.append(current)
|
||||
current = ""
|
||||
i += 2
|
||||
else:
|
||||
current += char
|
||||
i += 1
|
||||
|
||||
if current:
|
||||
result.append(current)
|
||||
|
||||
return result
|
||||
@@ -0,0 +1,28 @@
|
||||
# Copyright (c) Meta Platforms, Inc. and affiliates.
|
||||
#
|
||||
# This source code is licensed under the MIT license found in the
|
||||
# LICENSE file in the root directory of this source tree.
|
||||
|
||||
from .argument_parsing import (
|
||||
Argument,
|
||||
extract_qualifiers,
|
||||
format_arguments,
|
||||
format_parsed_type,
|
||||
FunctionModifiers,
|
||||
parse_arg_string,
|
||||
parse_function_pointer_argstring,
|
||||
parse_type_with_argstrings,
|
||||
)
|
||||
from .qualified_path import parse_qualified_path
|
||||
|
||||
__all__ = [
|
||||
"Argument",
|
||||
"extract_qualifiers",
|
||||
"format_arguments",
|
||||
"format_parsed_type",
|
||||
"FunctionModifiers",
|
||||
"parse_arg_string",
|
||||
"parse_function_pointer_argstring",
|
||||
"parse_qualified_path",
|
||||
"parse_type_with_argstrings",
|
||||
]
|
||||
@@ -0,0 +1,531 @@
|
||||
# Copyright (c) Meta Platforms, Inc. and affiliates.
|
||||
#
|
||||
# This source code is licensed under the MIT license found in the
|
||||
# LICENSE file in the root directory of this source tree.
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import re
|
||||
from dataclasses import dataclass
|
||||
|
||||
# Type alias for a parsed argument tuple:
|
||||
# (qualifiers, type, name, default_value)
|
||||
# - qualifiers: leading CV-qualifiers like "const", "const volatile", or None
|
||||
# - type: the core type without leading CV-qualifiers
|
||||
# - name: the parameter name, or None if unnamedą
|
||||
# - default_value: the default value expression, or None
|
||||
Argument = tuple[str | None, str, str | None, str | None]
|
||||
|
||||
|
||||
@dataclass
|
||||
class FunctionModifiers:
|
||||
"""Parsed function modifiers that appear after the parameter list."""
|
||||
|
||||
is_const: bool = False
|
||||
is_override: bool = False
|
||||
is_final: bool = False
|
||||
is_noexcept: bool = False
|
||||
noexcept_expr: str | None = None
|
||||
is_pure_virtual: bool = False
|
||||
is_default: bool = False
|
||||
is_delete: bool = False
|
||||
|
||||
|
||||
# Pattern for function pointer / pointer to member / reference to array:
|
||||
# Matches: (*name), (Class::*name), (&name), (*name)[N]
|
||||
# Group 1: the identifier name
|
||||
_FUNC_PTR_PATTERN = re.compile(
|
||||
r"\(\s*" # Opening paren
|
||||
r"(?:[a-zA-Z_][a-zA-Z0-9_]*\s*::\s*)?" # Optional Class::
|
||||
r"[*&]\s*" # * or &
|
||||
r"([a-zA-Z_][a-zA-Z0-9_]*)" # Capture: identifier name
|
||||
r"\s*\)" # Closing paren
|
||||
)
|
||||
|
||||
# CV-qualifiers that should be extracted into the qualifiers field.
|
||||
# These precede a type but are not part of the type name itself, so
|
||||
# they must be separated to allow unambiguous type qualification later.
|
||||
_CV_QUALIFIERS = frozenset({"const", "volatile", "mutable"})
|
||||
|
||||
# Type specifiers that ARE part of the type name (e.g. "unsigned long").
|
||||
# They are kept in the type field, but are still used by
|
||||
# _prefix_is_all_qualifiers to detect patterns like "unsigned long"
|
||||
# where the last token completes the type rather than naming a parameter.
|
||||
_TYPE_SPECIFIERS = frozenset({"unsigned", "signed", "long", "short"})
|
||||
|
||||
# Union of CV-qualifiers and type specifiers. Used by
|
||||
# _prefix_is_all_qualifiers to decide whether a prefix consists entirely
|
||||
# of qualifier/specifier keywords.
|
||||
_CPP_TYPE_QUALIFIERS = _CV_QUALIFIERS | _TYPE_SPECIFIERS
|
||||
|
||||
|
||||
def _find_matching_bracket(
|
||||
s: str,
|
||||
start: int,
|
||||
open_char: str,
|
||||
close_char: str,
|
||||
ignore_inside: str | None = None,
|
||||
) -> int:
|
||||
"""Find the index of the closing bracket matching the opening one at start.
|
||||
|
||||
Args:
|
||||
s: The string to search.
|
||||
start: The index of the opening bracket.
|
||||
open_char: The opening bracket character (e.g., '(' or '<').
|
||||
close_char: The closing bracket character (e.g., ')' or '>').
|
||||
ignore_inside: Optional bracket type inside which to ignore matches.
|
||||
If '(', ignores matches inside parentheses. If '<', ignores inside angles.
|
||||
|
||||
Returns:
|
||||
The index of the matching closing bracket, or -1 if not found.
|
||||
"""
|
||||
if start >= len(s) or s[start] != open_char:
|
||||
return -1
|
||||
|
||||
depth = 0
|
||||
ignore_depth = 0
|
||||
ignore_open = ignore_close = ""
|
||||
if ignore_inside == "(":
|
||||
ignore_open, ignore_close = "(", ")"
|
||||
elif ignore_inside == "<":
|
||||
ignore_open, ignore_close = "<", ">"
|
||||
|
||||
for i in range(start, len(s)):
|
||||
c = s[i]
|
||||
if ignore_open and c == ignore_open:
|
||||
ignore_depth += 1
|
||||
elif ignore_close and c == ignore_close:
|
||||
ignore_depth -= 1
|
||||
elif c == open_char and ignore_depth == 0:
|
||||
depth += 1
|
||||
elif c == close_char and ignore_depth == 0:
|
||||
depth -= 1
|
||||
if depth == 0:
|
||||
return i
|
||||
|
||||
return -1
|
||||
|
||||
|
||||
def _find_matching_paren(s: str, start: int = 0) -> int:
|
||||
"""Find the index of the closing parenthesis matching the opening one at start."""
|
||||
return _find_matching_bracket(s, start, "(", ")")
|
||||
|
||||
|
||||
def _find_matching_angle(s: str, start: int = 0) -> int:
|
||||
"""Find the index of the closing angle bracket matching the opening one at start."""
|
||||
return _find_matching_bracket(s, start, "<", ">", ignore_inside="(")
|
||||
|
||||
|
||||
def _iter_at_depth_zero(s: str):
|
||||
"""Iterate over string, yielding (index, char, at_depth_zero) tuples.
|
||||
|
||||
Tracks nested parentheses, angle brackets, and braces. The at_depth_zero
|
||||
flag is True when all nesting depths are zero AFTER processing the current
|
||||
character (so brackets themselves are never at depth zero).
|
||||
"""
|
||||
paren_depth = angle_depth = brace_depth = 0
|
||||
|
||||
for i, c in enumerate(s):
|
||||
if c == "<":
|
||||
angle_depth += 1
|
||||
elif c == ">":
|
||||
angle_depth = max(0, angle_depth - 1)
|
||||
elif c == "(":
|
||||
paren_depth += 1
|
||||
elif c == ")":
|
||||
paren_depth = max(0, paren_depth - 1)
|
||||
elif c == "{":
|
||||
brace_depth += 1
|
||||
elif c == "}":
|
||||
brace_depth = max(0, brace_depth - 1)
|
||||
|
||||
yield i, c, (paren_depth == 0 and angle_depth == 0 and brace_depth == 0)
|
||||
|
||||
|
||||
def _split_arguments(args_str: str) -> list[str]:
|
||||
"""Split arguments by comma, respecting nested structures.
|
||||
|
||||
Handles:
|
||||
- Nested parentheses: std::function<int(int, int)>
|
||||
- Nested angle brackets: std::map<K, V>
|
||||
- Brace initializers: std::vector<int> v = {1, 2, 3}
|
||||
"""
|
||||
result = []
|
||||
current: list[str] = []
|
||||
|
||||
for _, c, at_zero in _iter_at_depth_zero(args_str):
|
||||
if c == "," and at_zero:
|
||||
result.append("".join(current).strip())
|
||||
current = []
|
||||
else:
|
||||
current.append(c)
|
||||
|
||||
if current:
|
||||
result.append("".join(current).strip())
|
||||
|
||||
return [arg for arg in result if arg]
|
||||
|
||||
|
||||
def _prefix_is_all_qualifiers(prefix: str) -> bool:
|
||||
"""Check if all tokens in the prefix are type qualifiers/specifiers.
|
||||
|
||||
When the prefix consists entirely of reserved qualifiers (e.g., "const",
|
||||
"const unsigned"), the following token cannot be a parameter name — it
|
||||
must be completing the type.
|
||||
"""
|
||||
return all(t in _CPP_TYPE_QUALIFIERS for t in prefix.split())
|
||||
|
||||
|
||||
def _looks_like_type_token(token: str) -> bool:
|
||||
"""Check if a token ends with type-related punctuation.
|
||||
|
||||
Returns True if the token ends with pointer, reference, template closer,
|
||||
or array bracket — indicating it's part of a type, not a name.
|
||||
"""
|
||||
return (
|
||||
token.endswith("*")
|
||||
or token.endswith("&")
|
||||
or token.endswith(">")
|
||||
or token.endswith("]")
|
||||
)
|
||||
|
||||
|
||||
def _find_default_value_start(arg: str) -> int:
|
||||
"""Find the position of '=' that starts a default value.
|
||||
|
||||
Returns -1 if no default value found.
|
||||
Ignores '=' inside nested structures like templates or lambdas.
|
||||
"""
|
||||
for i, c, at_zero in _iter_at_depth_zero(arg):
|
||||
if c == "=" and at_zero:
|
||||
return i
|
||||
return -1
|
||||
|
||||
|
||||
def extract_qualifiers(type_str: str) -> tuple[str | None, str]:
|
||||
"""Extract leading CV-qualifiers (const, volatile, mutable) from a type string.
|
||||
|
||||
Returns ``(qualifiers, core_type)`` where *qualifiers* is ``None`` when
|
||||
no leading CV-qualifiers are found or when extracting them would leave
|
||||
the type empty.
|
||||
|
||||
Examples::
|
||||
|
||||
"const std::string&" → ("const", "std::string&")
|
||||
"const volatile int*" → ("const volatile", "int*")
|
||||
"unsigned long" → (None, "unsigned long")
|
||||
"const unsigned long" → ("const", "unsigned long")
|
||||
"int" → (None, "int")
|
||||
"mutable std::mutex" → ("mutable", "std::mutex")
|
||||
"""
|
||||
if not type_str:
|
||||
return (None, "")
|
||||
|
||||
tokens = type_str.split()
|
||||
qual_count = 0
|
||||
for token in tokens:
|
||||
if token in _CV_QUALIFIERS:
|
||||
qual_count += 1
|
||||
else:
|
||||
break
|
||||
|
||||
# No leading qualifiers, or ALL tokens are qualifiers (e.g. just "const")
|
||||
# — keep them in the type to avoid producing an empty type string.
|
||||
if qual_count == 0 or qual_count >= len(tokens):
|
||||
return (None, type_str)
|
||||
|
||||
return (" ".join(tokens[:qual_count]), " ".join(tokens[qual_count:]))
|
||||
|
||||
|
||||
def _parse_single_argument(arg: str) -> Argument:
|
||||
"""Parse a single C++ argument into ``(qualifiers, type, name, default_value)``.
|
||||
|
||||
Leading CV-qualifiers (``const``, ``volatile``, ``mutable``) are extracted
|
||||
into the *qualifiers* field so the *type* field contains only the core
|
||||
type reference that may later need namespace qualification.
|
||||
|
||||
Handles complex cases::
|
||||
|
||||
"int x" → (None, "int", "x", None)
|
||||
"const std::string& s" → ("const", "std::string&", "s", None)
|
||||
"int x = 5" → (None, "int", "x", "5")
|
||||
"int (*callback)(int, int)" → (None, "int (*)(int, int)", "callback", None)
|
||||
"void (Class::*method)()" → (None, "void (Class::*)()", "method", None)
|
||||
"int (&arr)[10]" → (None, "int (&)[10]", "arr", None)
|
||||
"void" → (None, "void", None, None)
|
||||
"const unsigned long" → ("const", "unsigned long", None, None)
|
||||
"""
|
||||
arg = arg.strip()
|
||||
if not arg:
|
||||
return (None, "", None, None)
|
||||
|
||||
default_value: str | None = None
|
||||
base_arg = arg
|
||||
|
||||
# Handle default values: split on '=' but respect nested structures
|
||||
eq_pos = _find_default_value_start(arg)
|
||||
if eq_pos != -1:
|
||||
base_arg = arg[:eq_pos].strip()
|
||||
default_value = arg[eq_pos + 1 :].strip()
|
||||
|
||||
# Extract leading CV-qualifiers before further parsing
|
||||
qualifiers, base_arg = extract_qualifiers(base_arg)
|
||||
|
||||
# Try to match function pointer / pointer to member / reference to array pattern
|
||||
match = _FUNC_PTR_PATTERN.search(base_arg)
|
||||
if match:
|
||||
name = match.group(1)
|
||||
# Reconstruct type by removing the name from the pattern
|
||||
type_str = base_arg[: match.start(1)] + base_arg[match.end(1) :]
|
||||
return (qualifiers, type_str.strip(), name, default_value)
|
||||
|
||||
# Regular case: last token is the name
|
||||
parts = base_arg.rsplit(None, 1)
|
||||
if len(parts) == 2:
|
||||
prefix, potential_name = parts
|
||||
# The last token is NOT a name when:
|
||||
# - it looks like a type token (ends with *, &, >, ]), OR
|
||||
# - it is a CV-qualifier (trailing const/volatile), OR
|
||||
# - the prefix is all qualifiers/specifiers AND the last token is
|
||||
# also a type specifier (e.g. "unsigned long" — "long" completes
|
||||
# the type rather than naming a parameter).
|
||||
if (
|
||||
_looks_like_type_token(potential_name)
|
||||
or potential_name in _CV_QUALIFIERS
|
||||
or (
|
||||
_prefix_is_all_qualifiers(prefix) and potential_name in _TYPE_SPECIFIERS
|
||||
)
|
||||
):
|
||||
return (qualifiers, base_arg, None, default_value)
|
||||
return (qualifiers, prefix, potential_name, default_value)
|
||||
else:
|
||||
return (qualifiers, base_arg, None, default_value)
|
||||
|
||||
|
||||
def _parse_modifiers(modifiers_str: str) -> FunctionModifiers:
|
||||
"""Parse function modifiers after the parameter list.
|
||||
|
||||
Handles: const, override, final, noexcept, noexcept(expr), = 0, = default, = delete
|
||||
"""
|
||||
result = FunctionModifiers()
|
||||
s = modifiers_str.strip()
|
||||
|
||||
# Handle = 0, = default, = delete
|
||||
eq_match = re.search(r"=\s*(0|default|delete)\s*$", s)
|
||||
if eq_match:
|
||||
value = eq_match.group(1)
|
||||
if value == "0":
|
||||
result.is_pure_virtual = True
|
||||
elif value == "default":
|
||||
result.is_default = True
|
||||
elif value == "delete":
|
||||
result.is_delete = True
|
||||
s = s[: eq_match.start()].strip()
|
||||
|
||||
# Handle noexcept with optional expression
|
||||
noexcept_match = re.search(r"\bnoexcept\b", s)
|
||||
if noexcept_match:
|
||||
result.is_noexcept = True
|
||||
# Check for noexcept(expr)
|
||||
rest = s[noexcept_match.end() :]
|
||||
rest_stripped = rest.lstrip()
|
||||
if rest_stripped.startswith("("):
|
||||
paren_end = _find_matching_paren(rest_stripped, 0)
|
||||
if paren_end != -1:
|
||||
result.noexcept_expr = rest_stripped[1:paren_end].strip()
|
||||
# Remove noexcept and its expression from the string for further parsing
|
||||
s = s[: noexcept_match.start()] + s[noexcept_match.end() :]
|
||||
if result.noexcept_expr:
|
||||
# Also remove the (expr) part
|
||||
s = re.sub(r"\([^)]*\)", "", s, count=1)
|
||||
|
||||
# Parse remaining tokens
|
||||
tokens = s.split()
|
||||
for token in tokens:
|
||||
if token == "const":
|
||||
result.is_const = True
|
||||
elif token == "override":
|
||||
result.is_override = True
|
||||
elif token == "final":
|
||||
result.is_final = True
|
||||
|
||||
return result
|
||||
|
||||
|
||||
def parse_arg_string(
|
||||
arg_string: str,
|
||||
) -> tuple[list[Argument], FunctionModifiers]:
|
||||
"""Parse a C++ function argument string.
|
||||
|
||||
Args:
|
||||
arg_string: String in format "(type1 arg1, type2 arg2 = default) [modifiers]"
|
||||
|
||||
Returns:
|
||||
Tuple of (arguments, modifiers) where:
|
||||
- arguments: list of (qualifiers, type, name, default_value) tuples
|
||||
- modifiers: FunctionModifiers dataclass with parsed modifier flags
|
||||
"""
|
||||
arg_string = arg_string.strip()
|
||||
|
||||
if not arg_string.startswith("("):
|
||||
return ([], FunctionModifiers())
|
||||
|
||||
close_paren = _find_matching_paren(arg_string, 0)
|
||||
if close_paren == -1:
|
||||
return ([], FunctionModifiers())
|
||||
|
||||
args_content = arg_string[1:close_paren].strip()
|
||||
modifiers_str = arg_string[close_paren + 1 :]
|
||||
|
||||
arguments: list[Argument] = []
|
||||
if args_content:
|
||||
for arg in _split_arguments(args_content):
|
||||
parsed = _parse_single_argument(arg)
|
||||
if parsed[0] or parsed[1]:
|
||||
arguments.append(parsed)
|
||||
|
||||
modifiers = _parse_modifiers(modifiers_str)
|
||||
|
||||
return (arguments, modifiers)
|
||||
|
||||
|
||||
def format_arguments(arguments: list[Argument]) -> str:
|
||||
"""Format a list of parsed arguments into a comma-separated string.
|
||||
|
||||
Args:
|
||||
arguments: list of (qualifiers, type, name, default_value) tuples as
|
||||
returned by parse_arg_string or _parse_single_argument.
|
||||
|
||||
Returns:
|
||||
Formatted argument string, e.g. "const int x, float y = 0.0".
|
||||
"""
|
||||
parts = []
|
||||
for qualifiers, arg_type, arg_name, arg_default in arguments:
|
||||
part = ""
|
||||
if qualifiers:
|
||||
part += f"{qualifiers} "
|
||||
part += arg_type
|
||||
if arg_name:
|
||||
part += f" {arg_name}"
|
||||
if arg_default:
|
||||
part += f" = {arg_default}"
|
||||
parts.append(part)
|
||||
return ", ".join(parts)
|
||||
|
||||
|
||||
def parse_function_pointer_argstring(
|
||||
argstring: str,
|
||||
) -> list[Argument]:
|
||||
"""Parse a function pointer argstring of the form ')(args...)'.
|
||||
|
||||
Doxygen represents function pointer arguments in the argstring field
|
||||
starting with ')(' — the ')' closes the declarator and '(' opens
|
||||
the parameter list.
|
||||
|
||||
Args:
|
||||
argstring: Raw argstring from doxygen, e.g. ")(int x, float y)".
|
||||
|
||||
Returns:
|
||||
List of (qualifiers, type, name, default_value) tuples for each parameter.
|
||||
"""
|
||||
if not argstring or not argstring.startswith(")("):
|
||||
return []
|
||||
# Remove leading ')' to get '(args...)'
|
||||
inner = argstring[1:]
|
||||
arguments, _ = parse_arg_string(inner)
|
||||
return arguments
|
||||
|
||||
|
||||
def parse_type_with_argstrings(
|
||||
type_str: str,
|
||||
) -> list[str | list[Argument]]:
|
||||
"""Parse a type string, extracting inline function argument lists.
|
||||
|
||||
Doxygen sometimes embeds raw function signatures in type strings
|
||||
(e.g. for 'using' typedefs). This function splits the type into
|
||||
segments: plain-text fragments and parsed argument lists.
|
||||
|
||||
Each segment is either:
|
||||
- A ``str``: literal text (e.g. ``"void"``, ``"(*)"``).
|
||||
- A ``list[Argument]``: a parsed argument list,
|
||||
where each tuple is ``(qualifiers, type, name, default_value)``.
|
||||
|
||||
Handles cases like:
|
||||
- ``void(int x, float y)``
|
||||
→ ``["void", [(None, "int", "x", None), (None, "float", "y", None)]]``
|
||||
- ``std::function<void(int x, float y)>``
|
||||
→ ``["std::function<void", [(None, "int", "x", None), (None, "float", "y", None)], ">"]``
|
||||
- ``void(*)(int x, float y)``
|
||||
→ ``["void(*)", [(None, "int", "x", None), (None, "float", "y", None)]]``
|
||||
- ``int``
|
||||
→ ``["int"]``
|
||||
"""
|
||||
if not type_str:
|
||||
return [type_str] if type_str is not None else []
|
||||
|
||||
segments: list[str | list[Argument]] = []
|
||||
i = 0
|
||||
current_text: list[str] = []
|
||||
|
||||
while i < len(type_str):
|
||||
if type_str[i] == "(":
|
||||
close = _find_matching_paren(type_str, i)
|
||||
if close == -1:
|
||||
current_text.append(type_str[i])
|
||||
i += 1
|
||||
continue
|
||||
|
||||
inner = type_str[i + 1 : close]
|
||||
stripped = inner.strip()
|
||||
|
||||
# Check if this is a declarator like (*) or (&) — don't parse those
|
||||
if stripped in ("*", "&") or re.match(
|
||||
r"^[a-zA-Z_][a-zA-Z0-9_]*\s*::\s*[*&]$", stripped
|
||||
):
|
||||
current_text.append(type_str[i : close + 1])
|
||||
i = close + 1
|
||||
continue
|
||||
|
||||
# Try to parse as a function argument list
|
||||
args: list[Argument] = []
|
||||
if stripped:
|
||||
for arg in _split_arguments(stripped):
|
||||
parsed = _parse_single_argument(arg)
|
||||
if parsed[0] or parsed[1]:
|
||||
args.append(parsed)
|
||||
|
||||
if args:
|
||||
# Flush accumulated text as a plain segment
|
||||
if current_text:
|
||||
segments.append("".join(current_text))
|
||||
current_text = []
|
||||
segments.append(args)
|
||||
else:
|
||||
current_text.append(type_str[i : close + 1])
|
||||
i = close + 1
|
||||
else:
|
||||
current_text.append(type_str[i])
|
||||
i += 1
|
||||
|
||||
if current_text:
|
||||
segments.append("".join(current_text))
|
||||
|
||||
return segments
|
||||
|
||||
|
||||
def format_parsed_type(
|
||||
segments: list[str | list[Argument]],
|
||||
) -> str:
|
||||
"""Format the structured output of :func:`parse_type_with_argstrings` back
|
||||
into a type string.
|
||||
|
||||
Each segment is either a plain string (emitted as-is) or a parsed
|
||||
argument list (formatted as ``(qualifiers type name = default, ...)``).
|
||||
"""
|
||||
parts: list[str] = []
|
||||
for seg in segments:
|
||||
if isinstance(seg, str):
|
||||
parts.append(seg)
|
||||
else:
|
||||
parts.append(f"({format_arguments(seg)})")
|
||||
return "".join(parts)
|
||||
@@ -0,0 +1,65 @@
|
||||
# Copyright (c) Meta Platforms, Inc. and affiliates.
|
||||
#
|
||||
# This source code is licensed under the MIT license found in the
|
||||
# LICENSE file in the root directory of this source tree.
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
|
||||
def parse_qualified_path(path: str) -> list[str]:
|
||||
"""
|
||||
Parse a qualified path into a list of names.
|
||||
|
||||
Handles template syntax correctly by not splitting on "::" inside
|
||||
angle brackets. For example:
|
||||
- "std::vector<std::string>::test" -> ["std", "vector<std::string>", "test"]
|
||||
- "ns::Foo<A, B>::Bar" -> ["ns", "Foo<A, B>", "Bar"]
|
||||
|
||||
Also handles edge cases:
|
||||
- Comparison operators inside parentheses: "std::enable_if<(N > 0)>::type"
|
||||
- Arrow operators: "decltype(ptr->member)::type"
|
||||
- Bitshift operators: "std::integral_constant<int, (1 >> 2)>::value"
|
||||
"""
|
||||
result = []
|
||||
current = ""
|
||||
angle_depth = 0
|
||||
paren_depth = 0
|
||||
i = 0
|
||||
|
||||
while i < len(path):
|
||||
char = path[i]
|
||||
|
||||
if char == "(":
|
||||
paren_depth += 1
|
||||
current += char
|
||||
i += 1
|
||||
elif char == ")":
|
||||
paren_depth -= 1
|
||||
current += char
|
||||
i += 1
|
||||
elif char == "<" and paren_depth == 0:
|
||||
angle_depth += 1
|
||||
current += char
|
||||
i += 1
|
||||
elif char == ">" and paren_depth == 0:
|
||||
# Check for arrow operator "->" which should not affect angle_depth
|
||||
if i > 0 and path[i - 1] == "-":
|
||||
current += char
|
||||
i += 1
|
||||
else:
|
||||
angle_depth -= 1
|
||||
current += char
|
||||
i += 1
|
||||
elif path[i : i + 2] == "::" and angle_depth == 0 and paren_depth == 0:
|
||||
if current:
|
||||
result.append(current)
|
||||
current = ""
|
||||
i += 2
|
||||
else:
|
||||
current += char
|
||||
i += 1
|
||||
|
||||
if current:
|
||||
result.append(current)
|
||||
|
||||
return result
|
||||
+87
-95
@@ -3,11 +3,11 @@
|
||||
# This source code is licensed under the MIT license found in the
|
||||
# LICENSE file in the root directory of this source tree.
|
||||
|
||||
"""Unit tests for FunctionMember.parse_arg_string()"""
|
||||
"""Unit tests for parse_arg_string()"""
|
||||
|
||||
import unittest
|
||||
|
||||
from ..parser import FunctionMember, FunctionModifiers
|
||||
from ..parser.utils.argument_parsing import parse_arg_string
|
||||
|
||||
|
||||
class TestParseArgString(unittest.TestCase):
|
||||
@@ -19,24 +19,23 @@ class TestParseArgString(unittest.TestCase):
|
||||
|
||||
def test_empty_args(self):
|
||||
"""Empty parentheses"""
|
||||
args, mods = FunctionMember.parse_arg_string("()")
|
||||
args, mods = parse_arg_string("()")
|
||||
self.assertEqual(args, [])
|
||||
self.assertEqual(mods, FunctionModifiers())
|
||||
|
||||
def test_single_simple_arg(self):
|
||||
"""Single argument: int x"""
|
||||
args, mods = FunctionMember.parse_arg_string("(int x)")
|
||||
self.assertEqual(args, [("int", "x", None)])
|
||||
args, mods = parse_arg_string("(int x)")
|
||||
self.assertEqual(args, [(None, "int", "x", None)])
|
||||
|
||||
def test_multiple_simple_args(self):
|
||||
"""Multiple arguments: int x, float y"""
|
||||
args, mods = FunctionMember.parse_arg_string("(int x, float y)")
|
||||
self.assertEqual(args, [("int", "x", None), ("float", "y", None)])
|
||||
args, mods = parse_arg_string("(int x, float y)")
|
||||
self.assertEqual(args, [(None, "int", "x", None), (None, "float", "y", None)])
|
||||
|
||||
def test_void_arg(self):
|
||||
"""void with no name"""
|
||||
args, mods = FunctionMember.parse_arg_string("(void)")
|
||||
self.assertEqual(args, [("void", "", None)])
|
||||
args, mods = parse_arg_string("(void)")
|
||||
self.assertEqual(args, [(None, "void", None, None)])
|
||||
|
||||
# =========================================================================
|
||||
# Modifiers: const, override, final
|
||||
@@ -44,42 +43,42 @@ class TestParseArgString(unittest.TestCase):
|
||||
|
||||
def test_const_modifier(self):
|
||||
"""() const"""
|
||||
args, mods = FunctionMember.parse_arg_string("() const")
|
||||
args, mods = parse_arg_string("() const")
|
||||
self.assertTrue(mods.is_const)
|
||||
self.assertFalse(mods.is_override)
|
||||
|
||||
def test_override_modifier(self):
|
||||
"""() override"""
|
||||
args, mods = FunctionMember.parse_arg_string("() override")
|
||||
args, mods = parse_arg_string("() override")
|
||||
self.assertTrue(mods.is_override)
|
||||
self.assertFalse(mods.is_const)
|
||||
|
||||
def test_const_override(self):
|
||||
"""() const override"""
|
||||
args, mods = FunctionMember.parse_arg_string("() const override")
|
||||
args, mods = parse_arg_string("() const override")
|
||||
self.assertTrue(mods.is_const)
|
||||
self.assertTrue(mods.is_override)
|
||||
|
||||
def test_override_const(self):
|
||||
"""() override const - reversed order"""
|
||||
args, mods = FunctionMember.parse_arg_string("() override const")
|
||||
args, mods = parse_arg_string("() override const")
|
||||
self.assertTrue(mods.is_const)
|
||||
self.assertTrue(mods.is_override)
|
||||
|
||||
def test_final_modifier(self):
|
||||
"""() final"""
|
||||
args, mods = FunctionMember.parse_arg_string("() final")
|
||||
args, mods = parse_arg_string("() final")
|
||||
self.assertTrue(mods.is_final)
|
||||
|
||||
def test_override_final(self):
|
||||
"""() override final"""
|
||||
args, mods = FunctionMember.parse_arg_string("() override final")
|
||||
args, mods = parse_arg_string("() override final")
|
||||
self.assertTrue(mods.is_override)
|
||||
self.assertTrue(mods.is_final)
|
||||
|
||||
def test_const_override_final(self):
|
||||
"""() const override final"""
|
||||
args, mods = FunctionMember.parse_arg_string("() const override final")
|
||||
args, mods = parse_arg_string("() const override final")
|
||||
self.assertTrue(mods.is_const)
|
||||
self.assertTrue(mods.is_override)
|
||||
self.assertTrue(mods.is_final)
|
||||
@@ -90,31 +89,31 @@ class TestParseArgString(unittest.TestCase):
|
||||
|
||||
def test_noexcept(self):
|
||||
"""() noexcept"""
|
||||
args, mods = FunctionMember.parse_arg_string("() noexcept")
|
||||
args, mods = parse_arg_string("() noexcept")
|
||||
self.assertTrue(mods.is_noexcept)
|
||||
self.assertIsNone(mods.noexcept_expr)
|
||||
|
||||
def test_noexcept_true(self):
|
||||
"""() noexcept(true)"""
|
||||
args, mods = FunctionMember.parse_arg_string("() noexcept(true)")
|
||||
args, mods = parse_arg_string("() noexcept(true)")
|
||||
self.assertTrue(mods.is_noexcept)
|
||||
self.assertEqual(mods.noexcept_expr, "true")
|
||||
|
||||
def test_noexcept_false(self):
|
||||
"""() noexcept(false)"""
|
||||
args, mods = FunctionMember.parse_arg_string("() noexcept(false)")
|
||||
args, mods = parse_arg_string("() noexcept(false)")
|
||||
self.assertTrue(mods.is_noexcept)
|
||||
self.assertEqual(mods.noexcept_expr, "false")
|
||||
|
||||
def test_noexcept_expr(self):
|
||||
"""() noexcept(noexcept(other()))"""
|
||||
args, mods = FunctionMember.parse_arg_string("() noexcept(noexcept(other()))")
|
||||
args, mods = parse_arg_string("() noexcept(noexcept(other()))")
|
||||
self.assertTrue(mods.is_noexcept)
|
||||
self.assertEqual(mods.noexcept_expr, "noexcept(other())")
|
||||
|
||||
def test_const_noexcept(self):
|
||||
"""() const noexcept"""
|
||||
args, mods = FunctionMember.parse_arg_string("() const noexcept")
|
||||
args, mods = parse_arg_string("() const noexcept")
|
||||
self.assertTrue(mods.is_const)
|
||||
self.assertTrue(mods.is_noexcept)
|
||||
|
||||
@@ -124,28 +123,28 @@ class TestParseArgString(unittest.TestCase):
|
||||
|
||||
def test_pure_virtual(self):
|
||||
"""() = 0"""
|
||||
args, mods = FunctionMember.parse_arg_string("() = 0")
|
||||
args, mods = parse_arg_string("() = 0")
|
||||
self.assertTrue(mods.is_pure_virtual)
|
||||
|
||||
def test_default(self):
|
||||
"""() = default"""
|
||||
args, mods = FunctionMember.parse_arg_string("() = default")
|
||||
args, mods = parse_arg_string("() = default")
|
||||
self.assertTrue(mods.is_default)
|
||||
|
||||
def test_delete(self):
|
||||
"""() = delete"""
|
||||
args, mods = FunctionMember.parse_arg_string("() = delete")
|
||||
args, mods = parse_arg_string("() = delete")
|
||||
self.assertTrue(mods.is_delete)
|
||||
|
||||
def test_const_pure_virtual(self):
|
||||
"""() const = 0"""
|
||||
args, mods = FunctionMember.parse_arg_string("() const = 0")
|
||||
args, mods = parse_arg_string("() const = 0")
|
||||
self.assertTrue(mods.is_const)
|
||||
self.assertTrue(mods.is_pure_virtual)
|
||||
|
||||
def test_noexcept_default(self):
|
||||
"""() noexcept = default"""
|
||||
args, mods = FunctionMember.parse_arg_string("() noexcept = default")
|
||||
args, mods = parse_arg_string("() noexcept = default")
|
||||
self.assertTrue(mods.is_noexcept)
|
||||
self.assertTrue(mods.is_default)
|
||||
|
||||
@@ -155,31 +154,31 @@ class TestParseArgString(unittest.TestCase):
|
||||
|
||||
def test_std_map(self):
|
||||
"""std::map<K, V> with comma inside template"""
|
||||
args, mods = FunctionMember.parse_arg_string("(std::map<std::string, int> m)")
|
||||
self.assertEqual(args, [("std::map<std::string, int>", "m", None)])
|
||||
args, mods = parse_arg_string("(std::map<std::string, int> m)")
|
||||
self.assertEqual(args, [(None, "std::map<std::string, int>", "m", None)])
|
||||
|
||||
def test_std_unordered_map_nested(self):
|
||||
"""std::unordered_map<K, std::vector<V>>"""
|
||||
args, mods = FunctionMember.parse_arg_string(
|
||||
"(std::unordered_map<K, std::vector<V>> m)"
|
||||
args, mods = parse_arg_string("(std::unordered_map<K, std::vector<V>> m)")
|
||||
self.assertEqual(
|
||||
args, [(None, "std::unordered_map<K, std::vector<V>>", "m", None)]
|
||||
)
|
||||
self.assertEqual(args, [("std::unordered_map<K, std::vector<V>>", "m", None)])
|
||||
|
||||
def test_std_tuple(self):
|
||||
"""std::tuple<int, float, std::string>"""
|
||||
args, mods = FunctionMember.parse_arg_string(
|
||||
"(std::tuple<int, float, std::string> t)"
|
||||
args, mods = parse_arg_string("(std::tuple<int, float, std::string> t)")
|
||||
self.assertEqual(
|
||||
args, [(None, "std::tuple<int, float, std::string>", "t", None)]
|
||||
)
|
||||
self.assertEqual(args, [("std::tuple<int, float, std::string>", "t", None)])
|
||||
|
||||
def test_deeply_nested_templates(self):
|
||||
"""std::vector<std::vector<std::pair<int, int>>>"""
|
||||
args, mods = FunctionMember.parse_arg_string(
|
||||
args, mods = parse_arg_string(
|
||||
"(std::vector<std::vector<std::pair<int, int>>> v)"
|
||||
)
|
||||
self.assertEqual(
|
||||
args,
|
||||
[("std::vector<std::vector<std::pair<int, int>>>", "v", None)],
|
||||
[(None, "std::vector<std::vector<std::pair<int, int>>>", "v", None)],
|
||||
)
|
||||
|
||||
# =========================================================================
|
||||
@@ -188,23 +187,24 @@ class TestParseArgString(unittest.TestCase):
|
||||
|
||||
def test_std_function_simple(self):
|
||||
"""std::function<void()>"""
|
||||
args, mods = FunctionMember.parse_arg_string("(std::function<void()> f)")
|
||||
self.assertEqual(args, [("std::function<void()>", "f", None)])
|
||||
args, mods = parse_arg_string("(std::function<void()> f)")
|
||||
self.assertEqual(args, [(None, "std::function<void()>", "f", None)])
|
||||
|
||||
def test_std_function_with_args(self):
|
||||
"""std::function<int(int, int)>"""
|
||||
args, mods = FunctionMember.parse_arg_string("(std::function<int(int, int)> f)")
|
||||
self.assertEqual(args, [("std::function<int(int, int)>", "f", None)])
|
||||
args, mods = parse_arg_string("(std::function<int(int, int)> f)")
|
||||
self.assertEqual(args, [(None, "std::function<int(int, int)>", "f", None)])
|
||||
|
||||
def test_std_function_complex(self):
|
||||
"""std::function<void(const std::string&, size_t)>"""
|
||||
args, mods = FunctionMember.parse_arg_string(
|
||||
args, mods = parse_arg_string(
|
||||
"(std::function<void(const std::string&, size_t)> callback)"
|
||||
)
|
||||
self.assertEqual(
|
||||
args,
|
||||
[
|
||||
(
|
||||
None,
|
||||
"std::function<void(const std::string&, size_t)>",
|
||||
"callback",
|
||||
None,
|
||||
@@ -214,23 +214,23 @@ class TestParseArgString(unittest.TestCase):
|
||||
|
||||
def test_multiple_std_function_args(self):
|
||||
"""Multiple std::function args"""
|
||||
args, mods = FunctionMember.parse_arg_string(
|
||||
args, mods = parse_arg_string(
|
||||
"(std::function<int(int)> f, std::function<void(A, B)> g)"
|
||||
)
|
||||
self.assertEqual(
|
||||
args,
|
||||
[
|
||||
("std::function<int(int)>", "f", None),
|
||||
("std::function<void(A, B)>", "g", None),
|
||||
(None, "std::function<int(int)>", "f", None),
|
||||
(None, "std::function<void(A, B)>", "g", None),
|
||||
],
|
||||
)
|
||||
|
||||
def test_map_with_function_value(self):
|
||||
"""std::map<K, std::function<void(A, B)>>"""
|
||||
args, mods = FunctionMember.parse_arg_string(
|
||||
"(std::map<K, std::function<void(A, B)>> m)"
|
||||
args, mods = parse_arg_string("(std::map<K, std::function<void(A, B)>> m)")
|
||||
self.assertEqual(
|
||||
args, [(None, "std::map<K, std::function<void(A, B)>>", "m", None)]
|
||||
)
|
||||
self.assertEqual(args, [("std::map<K, std::function<void(A, B)>>", "m", None)])
|
||||
|
||||
# =========================================================================
|
||||
# Function pointers
|
||||
@@ -238,20 +238,20 @@ class TestParseArgString(unittest.TestCase):
|
||||
|
||||
def test_function_pointer_simple(self):
|
||||
"""int (*callback)(int, int)"""
|
||||
args, mods = FunctionMember.parse_arg_string("(int (*callback)(int, int))")
|
||||
self.assertEqual(args, [("int (*)(int, int)", "callback", None)])
|
||||
args, mods = parse_arg_string("(int (*callback)(int, int))")
|
||||
self.assertEqual(args, [(None, "int (*)(int, int)", "callback", None)])
|
||||
|
||||
def test_function_pointer_void(self):
|
||||
"""void (*handler)(const char*, size_t)"""
|
||||
args, mods = FunctionMember.parse_arg_string(
|
||||
"(void (*handler)(const char*, size_t))"
|
||||
args, mods = parse_arg_string("(void (*handler)(const char*, size_t))")
|
||||
self.assertEqual(
|
||||
args, [(None, "void (*)(const char*, size_t)", "handler", None)]
|
||||
)
|
||||
self.assertEqual(args, [("void (*)(const char*, size_t)", "handler", None)])
|
||||
|
||||
def test_function_pointer_no_args(self):
|
||||
"""void (*fn)()"""
|
||||
args, mods = FunctionMember.parse_arg_string("(void (*fn)())")
|
||||
self.assertEqual(args, [("void (*)()", "fn", None)])
|
||||
args, mods = parse_arg_string("(void (*fn)())")
|
||||
self.assertEqual(args, [(None, "void (*)()", "fn", None)])
|
||||
|
||||
# =========================================================================
|
||||
# Pointer to member function
|
||||
@@ -259,16 +259,14 @@ class TestParseArgString(unittest.TestCase):
|
||||
|
||||
def test_pointer_to_member(self):
|
||||
"""void (Class::*method)(int, int)"""
|
||||
args, mods = FunctionMember.parse_arg_string(
|
||||
"(void (Class::*method)(int, int))"
|
||||
)
|
||||
self.assertEqual(args, [("void (Class::*)(int, int)", "method", None)])
|
||||
args, mods = parse_arg_string("(void (Class::*method)(int, int))")
|
||||
self.assertEqual(args, [(None, "void (Class::*)(int, int)", "method", None)])
|
||||
|
||||
def test_pointer_to_member_const(self):
|
||||
"""int (Foo::*getter)() const - note: const after () is part of member fn signature"""
|
||||
args, mods = FunctionMember.parse_arg_string("(int (Foo::*getter)() const)")
|
||||
args, mods = parse_arg_string("(int (Foo::*getter)() const)")
|
||||
# The "const" here is part of the argument type, not a method modifier
|
||||
self.assertEqual(args, [("int (Foo::*)() const", "getter", None)])
|
||||
self.assertEqual(args, [(None, "int (Foo::*)() const", "getter", None)])
|
||||
|
||||
# =========================================================================
|
||||
# Reference to array / pointer to array
|
||||
@@ -276,13 +274,13 @@ class TestParseArgString(unittest.TestCase):
|
||||
|
||||
def test_reference_to_array(self):
|
||||
"""int (&arr)[10]"""
|
||||
args, mods = FunctionMember.parse_arg_string("(int (&arr)[10])")
|
||||
self.assertEqual(args, [("int (&)[10]", "arr", None)])
|
||||
args, mods = parse_arg_string("(int (&arr)[10])")
|
||||
self.assertEqual(args, [(None, "int (&)[10]", "arr", None)])
|
||||
|
||||
def test_pointer_to_array(self):
|
||||
"""int (*arr)[10]"""
|
||||
args, mods = FunctionMember.parse_arg_string("(int (*arr)[10])")
|
||||
self.assertEqual(args, [("int (*)[10]", "arr", None)])
|
||||
args, mods = parse_arg_string("(int (*arr)[10])")
|
||||
self.assertEqual(args, [(None, "int (*)[10]", "arr", None)])
|
||||
|
||||
# =========================================================================
|
||||
# Default arguments
|
||||
@@ -290,40 +288,36 @@ class TestParseArgString(unittest.TestCase):
|
||||
|
||||
def test_default_int(self):
|
||||
"""int x = 5"""
|
||||
args, mods = FunctionMember.parse_arg_string("(int x = 5)")
|
||||
self.assertEqual(args, [("int", "x", "5")])
|
||||
args, mods = parse_arg_string("(int x = 5)")
|
||||
self.assertEqual(args, [(None, "int", "x", "5")])
|
||||
|
||||
def test_default_string(self):
|
||||
"""std::string s = "default\" """
|
||||
args, mods = FunctionMember.parse_arg_string('(std::string s = "default")')
|
||||
self.assertEqual(args, [("std::string", "s", '"default"')])
|
||||
args, mods = parse_arg_string('(std::string s = "default")')
|
||||
self.assertEqual(args, [(None, "std::string", "s", '"default"')])
|
||||
|
||||
def test_default_nullptr(self):
|
||||
"""std::function<void()> f = nullptr"""
|
||||
args, mods = FunctionMember.parse_arg_string(
|
||||
"(std::function<void()> f = nullptr)"
|
||||
)
|
||||
self.assertEqual(args, [("std::function<void()>", "f", "nullptr")])
|
||||
args, mods = parse_arg_string("(std::function<void()> f = nullptr)")
|
||||
self.assertEqual(args, [(None, "std::function<void()>", "f", "nullptr")])
|
||||
|
||||
def test_default_brace_initializer(self):
|
||||
"""std::vector<int> v = {1, 2, 3}"""
|
||||
args, mods = FunctionMember.parse_arg_string("(std::vector<int> v = {1, 2, 3})")
|
||||
self.assertEqual(args, [("std::vector<int>", "v", "{1, 2, 3}")])
|
||||
args, mods = parse_arg_string("(std::vector<int> v = {1, 2, 3})")
|
||||
self.assertEqual(args, [(None, "std::vector<int>", "v", "{1, 2, 3}")])
|
||||
|
||||
def test_multiple_defaults(self):
|
||||
"""int x = 5, std::string s = "test\" """
|
||||
args, mods = FunctionMember.parse_arg_string(
|
||||
'(int x = 5, std::string s = "test")'
|
||||
)
|
||||
args, mods = parse_arg_string('(int x = 5, std::string s = "test")')
|
||||
self.assertEqual(
|
||||
args,
|
||||
[("int", "x", "5"), ("std::string", "s", '"test"')],
|
||||
[(None, "int", "x", "5"), (None, "std::string", "s", '"test"')],
|
||||
)
|
||||
|
||||
def test_default_template_with_comma(self):
|
||||
"""std::map<int, int> m = {}"""
|
||||
args, mods = FunctionMember.parse_arg_string("(std::map<int, int> m = {})")
|
||||
self.assertEqual(args, [("std::map<int, int>", "m", "{}")])
|
||||
args, mods = parse_arg_string("(std::map<int, int> m = {})")
|
||||
self.assertEqual(args, [(None, "std::map<int, int>", "m", "{}")])
|
||||
|
||||
# =========================================================================
|
||||
# Complex CV-qualifiers
|
||||
@@ -331,20 +325,18 @@ class TestParseArgString(unittest.TestCase):
|
||||
|
||||
def test_const_ref(self):
|
||||
"""const std::string& s"""
|
||||
args, mods = FunctionMember.parse_arg_string("(const std::string& s)")
|
||||
self.assertEqual(args, [("const std::string&", "s", None)])
|
||||
args, mods = parse_arg_string("(const std::string& s)")
|
||||
self.assertEqual(args, [("const", "std::string&", "s", None)])
|
||||
|
||||
def test_const_ptr_const_ref(self):
|
||||
"""const int* const& ptr"""
|
||||
args, mods = FunctionMember.parse_arg_string("(const int* const& ptr)")
|
||||
self.assertEqual(args, [("const int* const&", "ptr", None)])
|
||||
args, mods = parse_arg_string("(const int* const& ptr)")
|
||||
self.assertEqual(args, [("const", "int* const&", "ptr", None)])
|
||||
|
||||
def test_shared_ptr_const(self):
|
||||
"""const std::shared_ptr<const Foo>& p"""
|
||||
args, mods = FunctionMember.parse_arg_string(
|
||||
"(const std::shared_ptr<const Foo>& p)"
|
||||
)
|
||||
self.assertEqual(args, [("const std::shared_ptr<const Foo>&", "p", None)])
|
||||
args, mods = parse_arg_string("(const std::shared_ptr<const Foo>& p)")
|
||||
self.assertEqual(args, [("const", "std::shared_ptr<const Foo>&", "p", None)])
|
||||
|
||||
# =========================================================================
|
||||
# Mixed complex cases
|
||||
@@ -352,14 +344,14 @@ class TestParseArgString(unittest.TestCase):
|
||||
|
||||
def test_mixed_args_with_modifiers(self):
|
||||
"""Multiple complex args with const override"""
|
||||
args, mods = FunctionMember.parse_arg_string(
|
||||
args, mods = parse_arg_string(
|
||||
"(std::map<K, V> m, std::function<void(A, B)> f) const override"
|
||||
)
|
||||
self.assertEqual(
|
||||
args,
|
||||
[
|
||||
("std::map<K, V>", "m", None),
|
||||
("std::function<void(A, B)>", "f", None),
|
||||
(None, "std::map<K, V>", "m", None),
|
||||
(None, "std::function<void(A, B)>", "f", None),
|
||||
],
|
||||
)
|
||||
self.assertTrue(mods.is_const)
|
||||
@@ -367,15 +359,15 @@ class TestParseArgString(unittest.TestCase):
|
||||
|
||||
def test_full_complex_signature(self):
|
||||
"""Complex signature with everything"""
|
||||
args, mods = FunctionMember.parse_arg_string(
|
||||
args, mods = parse_arg_string(
|
||||
"(const std::vector<int>& v, "
|
||||
"std::function<int(int, int)> f = nullptr) const noexcept override"
|
||||
)
|
||||
self.assertEqual(
|
||||
args,
|
||||
[
|
||||
("const std::vector<int>&", "v", None),
|
||||
("std::function<int(int, int)>", "f", "nullptr"),
|
||||
("const", "std::vector<int>&", "v", None),
|
||||
(None, "std::function<int(int, int)>", "f", "nullptr"),
|
||||
],
|
||||
)
|
||||
self.assertTrue(mods.is_const)
|
||||
Reference in new issue
Block a user