pi-usereq 0.49.0 → 0.51.0

package/tests/fixtures_attended_results/project/find-line-numbers.json

@@ -1,5 +0,0 @@
-{
-  "code": 0,
-  "stdout": "@@@ <PROJECT_BASE>/src/fixture_c.c | c\n- @brief Comprehensive C language test fixture for parser validation.\n- @details Covers structs, unions, enums, function pointers, inline functions,\npreprocessor directives, bitfields, variadic functions, and complex\ntypedef chains that stress-test regex-based parsing.\n\n### IMPORT: `\"myheader.h\"`\n> Lines: 14-14\n```\n14: #include \"myheader.h\"\n```\n\n### IMPORT: `<stdarg.h>`\n> Lines: 15-15\n```\n15: #include <stdarg.h>\n```\n\n### IMPORT: `<stdio.h>`\n> Lines: 16-16\n```\n16: #include <stdio.h>\n```\n\n### IMPORT: `<stdlib.h>`\n> Lines: 17-17\n```\n17: #include <stdlib.h>\n```\n\n### IMPORT: `<string.h>`\n> Lines: 18-18\n```\n18: #include <string.h>\n```\n\n### VARIABLE: `i_val`\n> Signature: `int i_val`\n> Lines: 85-85\n- @brief Payload can hold either an integer or float value. */\n```\n85: int i_val;\n```\n\n### VARIABLE: `f_val`\n> Signature: `float f_val`\n> Lines: 86-86\n```\n86: float f_val;\n```\n\n### FUNCTION: `int`\n> Signature: `typedef int (*comparator_fn)(const void *a, const void *b)`\n> Lines: 124-142\n- @brief Function pointer type for generic comparison callbacks.\n- @brief Unary transform callback operating on a single integer.\n- @param a Pointer to first element.\n- @param b Pointer to second element.\n- @return Negative if a<b, zero if equal, positive if a>b.\n```\n124: typedef int (*comparator_fn)(const void *a, const void *b);\n130: typedef int (*transform_fn)(int value);\n138: typedef struct {\n139: const char *name;\n140: comparator_fn handler;\n141: int priority;\n142: } callback_entry_t;\n```\n\n### FUNCTION: `int`\n> Signature: `typedef int (*transform_fn)(int value)`\n> Lines: 130-142\n- @brief Unary transform callback operating on a single integer.\n```\n130: typedef int (*transform_fn)(int value);\n138: typedef struct {\n139: const char *name;\n140: comparator_fn handler;\n141: int priority;\n142: } callback_entry_t;\n```\n\n### VARIABLE: `counter`\n> Signature: `static int counter = 0`\n> Lines: 147-147\n- @brief Module-scoped invocation counter, not visible externally. */\n```\n147: static int counter = 0;\n```\n\n### VARIABLE: `error_buffer`\n> Signature: `static char error_buffer[256] = {0}`\n> Lines: 150-150\n- @brief Global error message buffer shared across translation unit. */\n```\n150: static char error_buffer[256] = {0};\n```\n\n### FUNCTION: `min_val`\n> Signature: `static inline int min_val(int a, int b) { return a < b ? a : b; }`\n> Lines: 160-160\n- @brief Compute the minimum of two integers.\n- @param a First integer.\n- @param b Second integer.\n- @return The smaller of a and b.\n```\n160: static inline int min_val(int a, int b) { return a < b ? a : b; }\n```\n\n### FUNCTION: `greet`\n> Signature: `void greet(const char *name)`\n> Lines: 168-174\n- @brief Print a greeting message to stdout.\n- @param name The recipient name; must not be NULL.\n```\n168: void greet(const char *name) {\n170: if (name == NULL) {\n171: return;\n172: }\n173: printf(\"Hello %s\\n\", name);\n174: }\n```\n\n### FUNCTION: `main`\n> Signature: `int main(int argc, char **argv)`\n> Lines: 182-190\n- @brief Application entry point.\n- @param argc Argument count from the OS.\n- @param argv Argument vector; argv[0] is the program name.\n- @return Exit code: 0 on success, 1 on error.\n```\n182: int main(int argc, char **argv) {\n183: if (argc < 2) {\n185: fprintf(stderr, \"Usage: %s <name>\\n\", argv[0]);\n186: return 1;\n187: }\n188: greet(argv[1]);\n189: return 0;\n190: }\n```\n\n### FUNCTION: `sum_ints`\n> Signature: `int sum_ints(int count, ...)`\n> Lines: 200-210\n- @brief Compute the sum of a variable number of integers.\n- @param count Number of integer arguments that follow.\n- @param ... Variable integer arguments to sum.\n- @return The cumulative sum of all provided integers.\n```\n200: int sum_ints(int count, ...) {\n201: va_list ap;\n202: va_start(ap, count);\n203: int total = 0;\n205: for (int i = 0; i < count; i++) {\n206: total += va_arg(ap, int);\n207: }\n208: va_end(ap);\n209: return total;\n210: }\n```\n\n### VARIABLE: `total`\n> Signature: `int total = 0`\n> Lines: 203-203\n```\n203: int total = 0;\n```\n\n### FUNCTION: `apply_transform`\n> Signature: `void apply_transform(int *arr, size_t len, transform_fn fn)`\n> Lines: 220-225\n- @brief Apply a transform function to every element in an array.\n- @param arr Array of integers to transform in-place.\n- @param len Number of elements in arr.\n- @param fn Transform callback applied to each element.\n```\n220: void apply_transform(int *arr, size_t len, transform_fn fn) {\n221: for (size_t i = 0; i < len; i++) {\n223: arr[i] = fn(arr[i]);\n224: }\n225: }\n```\n\n### FUNCTION: `factorial`\n> Signature: `unsigned long factorial(unsigned int n)`\n> Lines: 234-241\n- @brief Compute factorial recursively.\n- @param n Non-negative integer input.\n- @return n! or 1 when n <= 1.\n```\n234: unsigned long factorial(unsigned int n) {\n236: if (n <= 1) {\n237: return 1;\n238: }\n240: return n * factorial(n - 1);\n241: }\n```\n\n### FUNCTION: `fast_copy`\n> Signature: `static void fast_copy(void *restrict dest, const void *restrict src, size_t n)`\n> Lines: 251-253\n- @brief Copy bytes between non-overlapping buffers.\n- @param dest Destination buffer (restrict-qualified).\n- @param src Source buffer (restrict-qualified).\n- @param n Number of bytes to copy.\n```\n251: static void fast_copy(void *restrict dest, const void *restrict src, size_t n) {\n252: memcpy(dest, src, n);\n253: }\n```\n\n### FUNCTION: `read_volatile`\n> Signature: `static int read_volatile(volatile int *reg) { return *reg; }`\n> Lines: 260-260\n- @brief Read a hardware register marked volatile.\n- @param reg Pointer to the memory-mapped register.\n- @return The current 32-bit register value.\n```\n260: static int read_volatile(volatile int *reg) { return *reg; }\n```\n\n### FUNCTION: `sum_fixed`\n> Signature: `int sum_fixed(int arr[static 10])`\n> Lines: 269-275\n- @brief Sum elements of a fixed-size array.\n- @param arr Array with at least 10 elements (compiler hint via static 10).\n- @return The sum of the first 10 elements.\n```\n269: int sum_fixed(int arr[static 10]) {\n270: int s = 0;\n271: for (int i = 0; i < 10; i++) {\n272: s += arr[i];\n273: }\n274: return s;\n275: }\n```\n\n### VARIABLE: `s`\n> Signature: `int s = 0`\n> Lines: 270-270\n```\n270: int s = 0;\n```\n\n### VARIABLE: `x`\n> Signature: `int x`\n> Lines: 279-279\n```\n279: int x;\n```\n\n### VARIABLE: `y`\n> Signature: `int y`\n> Lines: 280-280\n```\n280: int y;\n```\n\n### VARIABLE: `a11`\n> Signature: `int a11`\n> Lines: 283-283\n```\n283: int a11;\n```\n\n### VARIABLE: `a22`\n> Signature: `int a22`\n> Lines: 284-284\n```\n284: int a22;\n```\n\n### VARIABLE: `i`\n> Signature: `int i`\n> Lines: 291-291\n```\n291: int i;\n```\n\n### VARIABLE: `f`\n> Signature: `float f`\n> Lines: 292-292\n```\n292: float f;\n```\n\n### VARIABLE: `l`\n> Signature: `long l`\n> Lines: 296-296\n```\n296: long l;\n```\n\n### VARIABLE: `s`\n> Signature: `int s`\n> Lines: 299-299\n```\n299: int s;\n```\n\n### VARIABLE: `c`\n> Signature: `char c`\n> Lines: 300-300\n```\n300: char c;\n```\n\n### VARIABLE: `x`\n> Signature: `int x`\n> Lines: 303-303\n```\n303: int x;\n```\n\n### VARIABLE: `y`\n> Signature: `int y`\n> Lines: 304-304\n```\n304: int y;\n```\n\n### FUNCTION: `req_cover_c_1`\n> Signature: `int req_cover_c_1(int value) { return value + 1; }`\n> Lines: 319-319\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\n319: int req_cover_c_1(int value) { return value + 1; }\n```\n\n### FUNCTION: `req_cover_c_2`\n> Signature: `int req_cover_c_2(int value) { return value + 2; }`\n> Lines: 328-328\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\n328: int req_cover_c_2(int value) { return value + 2; }\n```\n\n### FUNCTION: `req_cover_c_3`\n> Signature: `int req_cover_c_3(int value) { return value + 3; }`\n> Lines: 337-337\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\n337: int req_cover_c_3(int value) { return value + 3; }\n```\n\n### FUNCTION: `req_cover_c_4`\n> Signature: `int req_cover_c_4(int value) { return value + 4; }`\n> Lines: 346-346\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\n346: int req_cover_c_4(int value) { return value + 4; }\n```\n\n### FUNCTION: `req_cover_c_5`\n> Signature: `int req_cover_c_5(int value) { return value + 5; }`\n> Lines: 355-355\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\n355: int req_cover_c_5(int value) { return value + 5; }\n```\n\n@@@ <PROJECT_BASE>/src/fixture_cpp.cpp | cpp\n- @brief Comprehensive C++ test fixture for parser stress-testing.\n- @details Covers templates, SFINAE, constexpr, lambdas, concepts, CRTP,\noperator overloading, move semantics, nested namespaces, and\nmodern C++20/23 constructs.\n\n### IMPORT: `<concepts>`\n> Lines: 13-13\n```\n13: #include <concepts>\n```\n\n### IMPORT: `<functional>`\n> Lines: 14-14\n```\n14: #include <functional>\n```\n\n### IMPORT: `<iostream>`\n> Lines: 15-15\n```\n15: #include <iostream>\n```\n\n### IMPORT: `<memory>`\n> Lines: 16-16\n```\n16: #include <memory>\n```\n\n### IMPORT: `<optional>`\n> Lines: 17-17\n```\n17: #include <optional>\n```\n\n### IMPORT: `<string>`\n> Lines: 18-18\n```\n18: #include <string>\n```\n\n### IMPORT: `<vector>`\n> Lines: 19-19\n```\n19: #include <vector>\n```\n\n### CLASS: `Container`\n> Signature: `template <Printable T> class Container`\n> Lines: 55-110\n- @brief Generic container with RAII semantics.\n@tparam T Element type; must satisfy Printable concept.\n- @brief Stored value of type T.\n```\n55: template <Printable T> class Container {\n56: public:\n57: T value;\n63: explicit Container(T v) : value(std::move(v)) {}\n69: Container(const Container &other) = default;\n75: Container(Container &&other) noexcept = default;\n82: Container &operator=(const Container &other) = default;\n89: Container &operator=(Container &&other) noexcept = default;\n92: ~Container() = default;\n100: friend std::ostream &operator<<(std::ostream &os, const Container &c) {\n101: return os << c.value;\n102: }\n109: bool operator==(const Container &other) const { return value == other.value; }\n110: };\n```\n\n### FUNCTION: `r`\n> Signature: `explicit Container(T v) : value(std::move(v)) {}`\n> Lines: 63-63\n- @brief Construct container with an initial value.\n- @param v The value to store.\n```\n63: explicit Container(T v) : value(std::move(v)) {}\n```\n\n### FUNCTION: `r`\n> Signature: `Container(const Container &other) = default`\n> Lines: 69-102\n- @brief Copy constructor performs deep copy.\n- @brief Move constructor transfers ownership.\n- @param other Source container to copy from.\n- @param other Source container; left in valid but unspecified state.\n```\n69: Container(const Container &other) = default;\n75: Container(Container &&other) noexcept = default;\n82: Container &operator=(const Container &other) = default;\n89: Container &operator=(Container &&other) noexcept = default;\n92: ~Container() = default;\n100: friend std::ostream &operator<<(std::ostream &os, const Container &c) {\n101: return os << c.value;\n102: }\n```\n\n### FUNCTION: `r`\n> Signature: `Container(Container &&other) noexcept = default`\n> Lines: 75-102\n- @brief Move constructor transfers ownership.\n- @brief Copy assignment operator.\n- @param other Source container; left in valid but unspecified state.\n- @param other Source container.\n- @return Reference to this container.\n```\n75: Container(Container &&other) noexcept = default;\n82: Container &operator=(const Container &other) = default;\n89: Container &operator=(Container &&other) noexcept = default;\n92: ~Container() = default;\n100: friend std::ostream &operator<<(std::ostream &os, const Container &c) {\n101: return os << c.value;\n102: }\n```\n\n### FUNCTION: `dist_sq`\n> Signature: `constexpr double dist_sq(const Point &other) const`\n> Lines: 127-132\n- @brief Compute Euclidean distance squared to another point.\n- @param other Target point.\n- @return Distance squared (avoids sqrt overhead).\n```\n127: constexpr double dist_sq(const Point &other) const {\n129: double dx = x - other.x;\n130: double dy = y - other.y;\n131: return dx * dx + dy * dy;\n132: }\n```\n\n### CLASS: `Cloneable`\n> Signature: `template <typename Derived> class Cloneable`\n> Lines: 175-185\n- @brief CRTP base providing a polymorphic clone method.\n@tparam Derived The concrete class inheriting this base.\n- @brief Create a heap-allocated copy of the derived object.\n- @return Unique pointer to the cloned instance.\n```\n175: template <typename Derived> class Cloneable {\n176: public:\n181: std::unique_ptr<Derived> clone() const {\n183: return std::make_unique<Derived>(static_cast<const Derived &>(*this));\n184: }\n185: };\n```\n\n### CLASS: `Base`\n> Signature: `class Base`\n> Lines: 193-201\n- @brief Abstract base with a pure virtual method.\n- @brief Identify the concrete type at runtime.\n- @return A non-owning string literal naming the type.\n```\n193: class Base {\n194: public:\n199: virtual const char *type_name() const = 0;\n200: virtual ~Base() = default;\n201: };\n```\n\n### FUNCTION: `type_name`\n> Signature: `virtual const char *type_name() const = 0`\n> Lines: 199-207\n- @brief Identify the concrete type at runtime.\n- @return A non-owning string literal naming the type.\n```\n199: virtual const char *type_name() const = 0;\n200: virtual ~Base() = default;\n201: };\n207: class DerivedA : public virtual Base {\n```\n\n### CLASS: `DerivedA`\n> Signature: `class DerivedA : public virtual Base`\n> Lines: 207-210\n- @brief First concrete implementation of Base.\n```\n207: class DerivedA : public virtual Base {\n208: public:\n209: const char *type_name() const override { return \"DerivedA\"; }\n210: };\n```\n\n### FUNCTION: `type_name`\n> Signature: `const char *type_name() const override { return \"DerivedA\"; }`\n> Lines: 209-209\n```\n209: const char *type_name() const override { return \"DerivedA\"; }\n```\n\n### CLASS: `DerivedB`\n> Signature: `class DerivedB : public virtual Base`\n> Lines: 216-219\n- @brief Second concrete implementation for diamond inheritance testing.\n```\n216: class DerivedB : public virtual Base {\n217: public:\n218: const char *type_name() const override { return \"DerivedB\"; }\n219: };\n```\n\n### FUNCTION: `type_name`\n> Signature: `const char *type_name() const override { return \"DerivedB\"; }`\n> Lines: 218-218\n```\n218: const char *type_name() const override { return \"DerivedB\"; }\n```\n\n### CLASS: `Diamond`\n> Signature: `class Diamond : public DerivedA, public DerivedB`\n> Lines: 225-228\n- @brief Diamond inheritance: inherits from both DerivedA and DerivedB.\n```\n225: class Diamond : public DerivedA, public DerivedB {\n226: public:\n227: const char *type_name() const override { return \"Diamond\"; }\n228: };\n```\n\n### FUNCTION: `type_name`\n> Signature: `const char *type_name() const override { return \"Diamond\"; }`\n> Lines: 227-227\n```\n227: const char *type_name() const override { return \"Diamond\"; }\n```\n\n### FUNCTION: `f`\n> Signature: `if (pos == std::string::npos)`\n> Lines: 251-254\n- @brief Parse a key=value string into its components.\n- @param input String in \"key=value\" format.\n- @return Pair of key and value; empty strings if malformed.\n```\n251: if (pos == std::string::npos) {\n253: return {\"\", \"\"};\n254: }\n```\n\n### FUNCTION: `greet`\n> Signature: `void greet(std::string name) { std::cout << \"Hello, \" << name << \"\\n\"; }`\n> Lines: 264-264\n- @brief Greet a person by name on stdout.\n- @param name The person's name to display.\n```\n264: void greet(std::string name) { std::cout << \"Hello, \" << name << \"\\n\"; }\n```\n\n### FUNCTION: `main`\n> Signature: `int main()`\n> Lines: 270-275\n- @brief Program entry point.\n- @return 0 on success.\n```\n270: int main() {\n272: auto [key, val] = parse_kv(\"lang=cpp\");\n273: greet(key);\n274: return 0;\n275: }\n```\n\n### FUNCTION: `t`\n> Signature: `greet(key)`\n> Lines: 273-284\n```\n273: greet(key);\n274: return 0;\n275: }\n284: constexpr auto square = [](auto x) { return x * x; };\n```\n\n### FUNCTION: `format_int`\n> Signature: `inline std::string format_int(int v) { return std::to_string(v); }`\n> Lines: 295-295\n- @brief Internal helper formatting integers to strings.\n- @param v The integer to format.\n- @return Formatted string representation.\n```\n295: inline std::string format_int(int v) { return std::to_string(v); }\n```\n\n### FUNCTION: `std::to_string`\n> Signature: `return std::to_string(value)`\n> Lines: 310-318\n- @brief SFINAE-enabled serialize function for Numeric types.\n@tparam T Numeric type.\n- @brief Overload for string serialization (identity transform).\n- @param value The numeric value to serialize.\n- @param value The string to serialize.\n- @return String representation of the value.\n- @return The input string unchanged.\n```\n310: return std::to_string(value);\n311: }\n318: inline std::string serialize(const std::string &value) { return value; }\n```\n\n### FUNCTION: `serialize`\n> Signature: `inline std::string serialize(const std::string &value) { return value; }`\n> Lines: 318-318\n- @brief Overload for string serialization (identity transform).\n- @param value The string to serialize.\n- @return The input string unchanged.\n```\n318: inline std::string serialize(const std::string &value) { return value; }\n```\n\n### FUNCTION: `add_one`\n> Signature: `inline int add_one(int v) { return v + 1; }`\n> Lines: 344-344\n```\n344: inline int add_one(int v) { return v + 1; }\n```\n\n### FUNCTION: `ping`\n> Signature: `inline int ping() { return 1; }`\n> Lines: 347-347\n```\n347: inline int ping() { return 1; }\n```\n\n### FUNCTION: `pong`\n> Signature: `inline int pong() { return 2; }`\n> Lines: 350-350\n```\n350: inline int pong() { return 2; }\n```\n\n### FUNCTION: `req_cover_cpp_1`\n> Signature: `int req_cover_cpp_1(int value) { return value + 1; }`\n> Lines: 366-366\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\n366: int req_cover_cpp_1(int value) { return value + 1; }\n```\n\n### FUNCTION: `req_cover_cpp_2`\n> Signature: `int req_cover_cpp_2(int value) { return value + 2; }`\n> Lines: 375-375\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\n375: int req_cover_cpp_2(int value) { return value + 2; }\n```\n\n### FUNCTION: `req_cover_cpp_3`\n> Signature: `int req_cover_cpp_3(int value) { return value + 3; }`\n> Lines: 384-384\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\n384: int req_cover_cpp_3(int value) { return value + 3; }\n```\n\n### FUNCTION: `req_cover_cpp_4`\n> Signature: `int req_cover_cpp_4(int value) { return value + 4; }`\n> Lines: 393-393\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\n393: int req_cover_cpp_4(int value) { return value + 4; }\n```\n\n### FUNCTION: `req_cover_cpp_5`\n> Signature: `int req_cover_cpp_5(int value) { return value + 5; }`\n> Lines: 402-402\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\n402: int req_cover_cpp_5(int value) { return value + 5; }\n```\n\n@@@ <PROJECT_BASE>/src/fixture_csharp.cs | csharp\n\n### IMPORT: `System`\n> Lines: 9-9\n```\n9: using System;\n```\n\n### IMPORT: `System.Collections.Generic`\n> Lines: 10-10\n```\n10: using System.Collections.Generic;\n```\n\n### IMPORT: `System.Linq`\n> Lines: 11-11\n```\n11: using System.Linq;\n```\n\n### IMPORT: `System.Threading.Tasks`\n> Lines: 12-12\n```\n12: using System.Threading.Tasks;\n```\n\n### IMPORT: `System.Threading`\n> Lines: 13-13\n```\n13: using System.Threading;\n```\n\n### DECORATOR: `AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)`\n> Lines: 39-39\n```\n39: [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]\n```\n\n### CLASS: `AuditableAttribute`\n> Signature: `public class AuditableAttribute : Attribute`\n> Lines: 40-43\n```\n40: public class AuditableAttribute : Attribute {\n42: public int Level { get; set; } = 1;\n43: }\n```\n\n### DECORATOR: `Serializable`\n> Lines: 51-51\n```\n51: [Serializable]\n```\n\n### DECORATOR: `Auditable(Level = 2)`\n> Lines: 52-52\n```\n52: [Auditable(Level = 2)]\n```\n\n### CLASS: `Person`\n> Signature: `public class Person : IComparable<Person>, IDisposable`\n> Lines: 53-172\n```\n53: public class Person : IComparable<Person>, IDisposable {\n55: public const int MAX_AGE = 150;\n58: private static int _instanceCount = 0;\n61: private string _name;\n68: public string Name {\n69: get => _name;\n70: set {\n72: if (string.IsNullOrWhiteSpace(value))\n73: throw new ArgumentException(\"Name cannot be empty\");\n74: _name = value;\n75: }\n76: }\n79: public int Age { get; init; }\n82: public string? Email { get; set; }\n85: public Guid Id { get; } = Guid.NewGuid();\n90: public event DataChangedHandler? OnDataChanged;\n97: public Person(string name, int age) {\n98: _name = name;\n99: Age = age;\n100: Interlocked.Increment(ref _instanceCount);\n101: }\n106: public void Greet() {\n108: OnDataChanged?.Invoke(this, $\"Greeted {Name}\");\n109: Console.WriteLine($\"Hello, {Name}!\");\n110: }\n117: public static async Task<string> FetchAsync(CancellationToken token = default) {\n118: await Task.Delay(100, token);\n119: return \"data\";\n120: }\n127: public int CompareTo(Person? other) {\n128: if (other is null) return 1;\n129: return Age.CompareTo(other.Age);\n130: }\n135: public void Dispose() {\n137: Interlocked.Decrement(ref _instanceCount);\n138: GC.SuppressFinalize(this);\n139: }\n146: public object? this[string propertyName] {\n147: get {\n148: return propertyName switch {\n149: \"Name\" => Name,\n150: \"Age\" => Age,\n151: \"Email\" => Email,\n152: _ => null,\n153: };\n154: }\n155: }\n162: public void Deconstruct(out string name, out int age) {\n163: name = Name;\n164: age = Age;\n165: }\n171: public static int GetInstanceCount() => _instanceCount;\n172: }\n```\n\n### FUNCTION: `Person`\n> Signature: `public Person(string name, int age)`\n> Lines: 97-101\n- @brief Construct a new Person with name and age.\n- @details Initializes backing fields and updates instance counters.\n- @param name Display name (required).\n- @param age Age in years (must be 0..MAX_AGE).\n- @return Constructed Person instance.\n```\n97: public Person(string name, int age) {\n98: _name = name;\n99: Age = age;\n100: Interlocked.Increment(ref _instanceCount);\n101: }\n```\n\n### FUNCTION: `Greet`\n> Signature: `public void Greet()`\n> Lines: 106-110\n```\n106: public void Greet() {\n108: OnDataChanged?.Invoke(this, $\"Greeted {Name}\");\n109: Console.WriteLine($\"Hello, {Name}!\");\n110: }\n```\n\n### FUNCTION: `FetchAsync`\n> Signature: `public static async Task<string> FetchAsync(CancellationToken token = default)`\n> Lines: 117-120\n- @brief Fetch person data asynchronously with cancellation support.\n- @details Waits asynchronously and returns a deterministic payload.\n- @details Supports cancellation through token propagation.\n- @param token Cancellation token for cooperative cancellation.\n- @return Formatted data string.\n```\n117: public static async Task<string> FetchAsync(CancellationToken token = default) {\n118: await Task.Delay(100, token);\n119: return \"data\";\n120: }\n```\n\n### FUNCTION: `CompareTo`\n> Signature: `public int CompareTo(Person? other)`\n> Lines: 127-130\n- @brief Compare persons by age for sorting.\n- @details Implements IComparable ordering semantics.\n- @details Null values are ordered after non-null instances.\n- @param other Person to compare with.\n- @return Comparison result: negative, zero, or positive.\n```\n127: public int CompareTo(Person? other) {\n128: if (other is null) return 1;\n129: return Age.CompareTo(other.Age);\n130: }\n```\n\n### FUNCTION: `Dispose`\n> Signature: `public void Dispose()`\n> Lines: 135-139\n```\n135: public void Dispose() {\n137: Interlocked.Decrement(ref _instanceCount);\n138: GC.SuppressFinalize(this);\n139: }\n```\n\n### FUNCTION: `Deconstruct`\n> Signature: `public void Deconstruct(out string name, out int age)`\n> Lines: 162-165\n```\n162: public void Deconstruct(out string name, out int age) {\n163: name = Name;\n164: age = Age;\n165: }\n```\n\n### FUNCTION: `GetInstanceCount`\n> Signature: `public static int GetInstanceCount() => _instanceCount`\n> Lines: 171-179\n```\n171: public static int GetInstanceCount() => _instanceCount;\n172: }\n179: public interface IGreeter {\n```\n\n### FUNCTION: `SayHello`\n> Signature: `void SayHello(string name)`\n> Lines: 184-192\n```\n184: void SayHello(string name);\n190: void SayGoodbye(string name) {\n191: Console.WriteLine($\"Goodbye, {name}\");\n192: }\n```\n\n### FUNCTION: `SayGoodbye`\n> Signature: `void SayGoodbye(string name)`\n> Lines: 190-192\n```\n190: void SayGoodbye(string name) {\n191: Console.WriteLine($\"Goodbye, {name}\");\n192: }\n```\n\n### FUNCTION: `FindByIdAsync`\n> Signature: `Task<T?> FindByIdAsync(int id)`\n> Lines: 201-215\n```\n201: Task<T?> FindByIdAsync(int id);\n204: IAsyncEnumerable<T> GetAllAsync(CancellationToken token = default);\n207: Task<bool> SaveAsync(T entity);\n208: }\n215: public readonly struct Point {\n```\n\n### FUNCTION: `GetAllAsync`\n> Signature: `IAsyncEnumerable<T> GetAllAsync(CancellationToken token = default)`\n> Lines: 204-215\n```\n204: IAsyncEnumerable<T> GetAllAsync(CancellationToken token = default);\n207: Task<bool> SaveAsync(T entity);\n208: }\n215: public readonly struct Point {\n```\n\n### FUNCTION: `SaveAsync`\n> Signature: `Task<bool> SaveAsync(T entity)`\n> Lines: 207-215\n```\n207: Task<bool> SaveAsync(T entity);\n208: }\n215: public readonly struct Point {\n```\n\n### DECORATOR: `Flags`\n> Lines: 237-237\n```\n237: [Flags]\n```\n\n### FUNCTION: `ConfigEntry`\n> Signature: `public record ConfigEntry(string Key, string Value)`\n> Lines: 258-292\n```\n258: public record ConfigEntry(string Key, string Value);\n265: public record struct Vector2(double X, double Y);\n272: public static class StringExtensions {\n279: public static string Truncate(this string str, int maxLength) {\n280: if (str.Length <= maxLength) return str;\n281: return str[..maxLength] + \"...\";\n282: }\n289: public static bool IsAscii(this string str) {\n290: return str.All(c => c < 128);\n291: }\n292: }\n```\n\n### CLASS: `StringExtensions`\n> Signature: `public static class StringExtensions`\n> Lines: 272-292\n```\n272: public static class StringExtensions {\n279: public static string Truncate(this string str, int maxLength) {\n280: if (str.Length <= maxLength) return str;\n281: return str[..maxLength] + \"...\";\n282: }\n289: public static bool IsAscii(this string str) {\n290: return str.All(c => c < 128);\n291: }\n292: }\n```\n\n### FUNCTION: `Truncate`\n> Signature: `public static string Truncate(this string str, int maxLength)`\n> Lines: 279-282\n```\n279: public static string Truncate(this string str, int maxLength) {\n280: if (str.Length <= maxLength) return str;\n281: return str[..maxLength] + \"...\";\n282: }\n```\n\n### FUNCTION: `IsAscii`\n> Signature: `public static bool IsAscii(this string str)`\n> Lines: 289-291\n```\n289: public static bool IsAscii(this string str) {\n290: return str.All(c => c < 128);\n291: }\n```\n\n### CLASS: `SortedCollection`\n> Signature: `public class SortedCollection<T> where T : IComparable<T>`\n> Lines: 300-322\n```\n300: public class SortedCollection<T> where T : IComparable<T> {\n301: private readonly List<T> _items = new();\n307: public void Add(T item) {\n309: var index = _items.BinarySearch(item);\n310: if (index < 0) index = ~index;\n311: _items.Insert(index, item);\n312: }\n319: public IEnumerable<T> Where(Func<T, bool> predicate) {\n320: return _items.Where(predicate);\n321: }\n322: }\n```\n\n### FUNCTION: `Add`\n> Signature: `public void Add(T item)`\n> Lines: 307-312\n```\n307: public void Add(T item) {\n309: var index = _items.BinarySearch(item);\n310: if (index < 0) index = ~index;\n311: _items.Insert(index, item);\n312: }\n```\n\n### FUNCTION: `Where`\n> Signature: `public IEnumerable<T> Where(Func<T, bool> predicate)`\n> Lines: 319-321\n```\n319: public IEnumerable<T> Where(Func<T, bool> predicate) {\n320: return _items.Where(predicate);\n321: }\n```\n\n### CLASS: `PatternMatcher`\n> Signature: `public static class PatternMatcher`\n> Lines: 329-347\n```\n329: public static class PatternMatcher {\n335: public static string Describe(object? obj) {\n336: return obj switch {\n337: null => \"null\",\n338: int i when i > 0 => $\"positive int: {i}\",\n339: int i => $\"non-positive int: {i}\",\n340: string { Length: 0 } => \"empty string\",\n341: string s => $\"string({s.Length}): {s}\",\n342: Person { Age: >= 18 } p => $\"adult: {p.Name}\",\n343: Person p => $\"minor: {p.Name}\",\n344: _ => $\"unknown: {obj.GetType().Name}\",\n345: };\n346: }\n347: }\n```\n\n### FUNCTION: `Describe`\n> Signature: `public static string Describe(object? obj)`\n> Lines: 335-346\n```\n335: public static string Describe(object? obj) {\n336: return obj switch {\n337: null => \"null\",\n338: int i when i > 0 => $\"positive int: {i}\",\n339: int i => $\"non-positive int: {i}\",\n340: string { Length: 0 } => \"empty string\",\n341: string s => $\"string({s.Length}): {s}\",\n342: Person { Age: >= 18 } p => $\"adult: {p.Name}\",\n343: Person p => $\"minor: {p.Name}\",\n344: _ => $\"unknown: {obj.GetType().Name}\",\n345: };\n346: }\n```\n\n### DECORATOR: `DebuggerDisplay(\"{Value}\")`\n> Lines: 367-367\n```\n367: [DebuggerDisplay(\"{Value}\")]\n```\n\n### CLASS: `ReqCoverCsharp`\n> Signature: `public static class ReqCoverCsharp`\n> Lines: 374-410\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n```\n374: public static class ReqCoverCsharp {\n380: public static int ReqCoverCsharp1(int value) { return value + 1; }\n387: public static int ReqCoverCsharp2(int value) { return value + 2; }\n394: public static int ReqCoverCsharp3(int value) { return value + 3; }\n401: public static int ReqCoverCsharp4(int value) { return value + 4; }\n408: public static int ReqCoverCsharp5(int value) { return value + 5; }\n410: }\n```\n\n### FUNCTION: `ReqCoverCsharp1`\n> Signature: `public static int ReqCoverCsharp1(int value) { return value + 1; }`\n> Lines: 380-380\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\n380: public static int ReqCoverCsharp1(int value) { return value + 1; }\n```\n\n### FUNCTION: `ReqCoverCsharp2`\n> Signature: `public static int ReqCoverCsharp2(int value) { return value + 2; }`\n> Lines: 387-387\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\n387: public static int ReqCoverCsharp2(int value) { return value + 2; }\n```\n\n### FUNCTION: `ReqCoverCsharp3`\n> Signature: `public static int ReqCoverCsharp3(int value) { return value + 3; }`\n> Lines: 394-394\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\n394: public static int ReqCoverCsharp3(int value) { return value + 3; }\n```\n\n### FUNCTION: `ReqCoverCsharp4`\n> Signature: `public static int ReqCoverCsharp4(int value) { return value + 4; }`\n> Lines: 401-401\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\n401: public static int ReqCoverCsharp4(int value) { return value + 4; }\n```\n\n### FUNCTION: `ReqCoverCsharp5`\n> Signature: `public static int ReqCoverCsharp5(int value) { return value + 5; }`\n> Lines: 408-408\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\n408: public static int ReqCoverCsharp5(int value) { return value + 5; }\n```\n\n@@@ <PROJECT_BASE>/src/fixture_elixir.ex | elixir\n\n### IMPORT: `GenServer`\n> Lines: 18-18\n```\n18:   use GenServer\n```\n\n### IMPORT: `Enum`\n> Lines: 19-19\n```\n19:   import Enum\n```\n\n### IMPORT: `MyApp.Config`\n> Lines: 20-20\n```\n20:   alias MyApp.Config\n```\n\n### IMPORT: `MyApp.Server.State`\n> Lines: 21-21\n```\n21:   alias MyApp.Server.State\n```\n\n### IMPORT: `Logger`\n> Lines: 22-22\n```\n22:   require Logger\n```\n\n### FUNCTION: `start_link`\n> Signature: `def start_link(opts) do`\n> Lines: 66-69\n```\n66:   def start_link(opts) do\n67:     name = Keyword.get(opts, :name, \"default\")\n68:     GenServer.start_link(__MODULE__, opts, name: via_tuple(name))\n69:   end\n```\n\n### FUNCTION: `add_item`\n> Signature: `def add_item(server, item) do`\n> Lines: 79-81\n```\n79:   def add_item(server, item) do\n80:     GenServer.call(server, {:add_item, item})\n81:   end\n```\n\n### FUNCTION: `get_items`\n> Signature: `def get_items(server) do`\n> Lines: 90-92\n```\n90:   def get_items(server) do\n91:     GenServer.call(server, :get_items)\n92:   end\n```\n\n### FUNCTION: `notify`\n> Signature: `def notify(server, event) do`\n> Lines: 102-104\n```\n102:   def notify(server, event) do\n103:     GenServer.cast(server, {:notify, event})\n104:   end\n```\n\n### FUNCTION: `via_tuple`\n> Signature: `defp via_tuple(name) do`\n> Lines: 111-113\n- @brief Generate a via-tuple for process registration.\n- @param name The server name.\n- @return Via-tuple for Registry lookup.\n```\n111:   defp via_tuple(name) do\n112:     {:via, Registry, {MyApp.Registry, name}}\n113:   end\n```\n\n### FUNCTION: `init`\n> Signature: `def init(opts) do`\n> Lines: 118-131\n```\n118:   def init(opts) do\n120:     name = Keyword.fetch!(opts, :name)\n121:     port = Keyword.get(opts, :port, 4000)\n123:     state = %__MODULE__{\n124:       name: name,\n125:       port: port,\n126:       started_at: DateTime.utc_now()\n127:     }\n129:     Logger.info(\"Server #{name} started on port #{port}\")\n130:     {:ok, state}\n131:   end\n```\n\n### FUNCTION: `handle_call`\n> Signature: `def handle_call({:add_item, item}, _from, state) do`\n> Lines: 134-142\n```\n134:   def handle_call({:add_item, item}, _from, state) do\n136:     if length(state.items) >= @max_items do\n137:       {:reply, {:error, :capacity_exceeded}, state}\n138:     else\n139:       new_state = %{state | items: [item | state.items]}\n140:       {:reply, :ok, new_state}\n141:     end\n142:   end\n```\n\n### FUNCTION: `handle_call`\n> Signature: `def handle_call(:get_items, _from, state) do`\n> Lines: 145-147\n```\n145:   def handle_call(:get_items, _from, state) do\n146:     {:reply, Enum.reverse(state.items), state}\n147:   end\n```\n\n### FUNCTION: `handle_cast`\n> Signature: `def handle_cast({:notify, event}, state) do`\n> Lines: 150-153\n```\n150:   def handle_cast({:notify, event}, state) do\n151:     Logger.debug(\"Received event: #{inspect(event)}\")\n152:     {:noreply, state}\n153:   end\n```\n\n### FUNCTION: `handle_info`\n> Signature: `def handle_info(:timeout, state) do`\n> Lines: 156-159\n```\n156:   def handle_info(:timeout, state) do\n157:     Logger.warn(\"Server #{state.name} timed out\")\n158:     {:noreply, state}\n159:   end\n```\n\n### FUNCTION: `handle_internal`\n> Signature: `defp handle_internal(state) do`\n> Lines: 164-168\n- @brief Handle internal state cleanup and maintenance.\n- @param state Current server state.\n- @return Updated state with pruned items.\n```\n164:   defp handle_internal(state) do\n166:     pruned = Enum.take(state.items, @max_items)\n167:     %{state | items: pruned}\n168:   end\n```\n\n### FUNCTION: `my_macro`\n> Signature: `defmacro my_macro(expr) do`\n> Lines: 176-182\n```\n176:   defmacro my_macro(expr) do\n177:     quote do\n178:       result = unquote(expr)\n179:       Logger.debug(\"Macro result: #{inspect(result)}\")\n180:       result\n181:     end\n182:   end\n```\n\n### FUNCTION: `print`\n> Signature: `def print(data)`\n> Lines: 199-200\n```\n199:   def print(data)\n200: end\n```\n\n### FUNCTION: `print`\n> Signature: `def print(server) do`\n> Lines: 211-213\n```\n211:   def print(server) do\n212:     \"Server(#{server.name}:#{server.port})\"\n213:   end\n```\n\n### FUNCTION: `print`\n> Signature: `def print(str) do`\n> Lines: 217-219\n```\n217:   def print(str) do\n218:     \"String(#{str})\"\n219:   end\n```\n\n### FUNCTION: `classify`\n> Signature: `def classify(value) when is_integer(value) and value > 0, do: :positive`\n> Lines: 237-258\n```\n237:   def classify(value) when is_integer(value) and value > 0, do: :positive\n238:   def classify(value) when is_integer(value) and value < 0, do: :negative\n239:   def classify(0), do: :zero\n240:   def classify(value) when is_binary(value), do: :string\n241:   def classify(value) when is_list(value), do: :list\n242:   def classify(_), do: :unknown\n244:   @doc \"\"\"\n245:   Process a list using pipe operator for data transformation.\n247:   @param items List of strings to process.\n248:   @return Sorted list of unique uppercase strings.\n249:   \"\"\"\n250:   @spec process_list(list(String.t())) :: list(String.t())\n251:   def process_list(items) do\n252:     items\n253:     |> Enum.map(&String.trim/1)\n254:     |> Enum.reject(&(&1 == \"\"))\n255:     |> Enum.map(&String.upcase/1)\n256:     |> Enum.uniq()\n257:     |> Enum.sort()\n258:   end\n```\n\n### FUNCTION: `classify`\n> Signature: `def classify(value) when is_integer(value) and value < 0, do: :negative`\n> Lines: 238-258\n```\n238:   def classify(value) when is_integer(value) and value < 0, do: :negative\n239:   def classify(0), do: :zero\n240:   def classify(value) when is_binary(value), do: :string\n241:   def classify(value) when is_list(value), do: :list\n242:   def classify(_), do: :unknown\n244:   @doc \"\"\"\n245:   Process a list using pipe operator for data transformation.\n247:   @param items List of strings to process.\n248:   @return Sorted list of unique uppercase strings.\n249:   \"\"\"\n250:   @spec process_list(list(String.t())) :: list(String.t())\n251:   def process_list(items) do\n252:     items\n253:     |> Enum.map(&String.trim/1)\n254:     |> Enum.reject(&(&1 == \"\"))\n255:     |> Enum.map(&String.upcase/1)\n256:     |> Enum.uniq()\n257:     |> Enum.sort()\n258:   end\n```\n\n### FUNCTION: `classify`\n> Signature: `def classify(0), do: :zero`\n> Lines: 239-258\n```\n239:   def classify(0), do: :zero\n240:   def classify(value) when is_binary(value), do: :string\n241:   def classify(value) when is_list(value), do: :list\n242:   def classify(_), do: :unknown\n244:   @doc \"\"\"\n245:   Process a list using pipe operator for data transformation.\n247:   @param items List of strings to process.\n248:   @return Sorted list of unique uppercase strings.\n249:   \"\"\"\n250:   @spec process_list(list(String.t())) :: list(String.t())\n251:   def process_list(items) do\n252:     items\n253:     |> Enum.map(&String.trim/1)\n254:     |> Enum.reject(&(&1 == \"\"))\n255:     |> Enum.map(&String.upcase/1)\n256:     |> Enum.uniq()\n257:     |> Enum.sort()\n258:   end\n```\n\n### FUNCTION: `classify`\n> Signature: `def classify(value) when is_binary(value), do: :string`\n> Lines: 240-258\n```\n240:   def classify(value) when is_binary(value), do: :string\n241:   def classify(value) when is_list(value), do: :list\n242:   def classify(_), do: :unknown\n244:   @doc \"\"\"\n245:   Process a list using pipe operator for data transformation.\n247:   @param items List of strings to process.\n248:   @return Sorted list of unique uppercase strings.\n249:   \"\"\"\n250:   @spec process_list(list(String.t())) :: list(String.t())\n251:   def process_list(items) do\n252:     items\n253:     |> Enum.map(&String.trim/1)\n254:     |> Enum.reject(&(&1 == \"\"))\n255:     |> Enum.map(&String.upcase/1)\n256:     |> Enum.uniq()\n257:     |> Enum.sort()\n258:   end\n```\n\n### FUNCTION: `classify`\n> Signature: `def classify(value) when is_list(value), do: :list`\n> Lines: 241-258\n```\n241:   def classify(value) when is_list(value), do: :list\n242:   def classify(_), do: :unknown\n244:   @doc \"\"\"\n245:   Process a list using pipe operator for data transformation.\n247:   @param items List of strings to process.\n248:   @return Sorted list of unique uppercase strings.\n249:   \"\"\"\n250:   @spec process_list(list(String.t())) :: list(String.t())\n251:   def process_list(items) do\n252:     items\n253:     |> Enum.map(&String.trim/1)\n254:     |> Enum.reject(&(&1 == \"\"))\n255:     |> Enum.map(&String.upcase/1)\n256:     |> Enum.uniq()\n257:     |> Enum.sort()\n258:   end\n```\n\n### FUNCTION: `classify`\n> Signature: `def classify(_), do: :unknown`\n> Lines: 242-258\n```\n242:   def classify(_), do: :unknown\n244:   @doc \"\"\"\n245:   Process a list using pipe operator for data transformation.\n247:   @param items List of strings to process.\n248:   @return Sorted list of unique uppercase strings.\n249:   \"\"\"\n250:   @spec process_list(list(String.t())) :: list(String.t())\n251:   def process_list(items) do\n252:     items\n253:     |> Enum.map(&String.trim/1)\n254:     |> Enum.reject(&(&1 == \"\"))\n255:     |> Enum.map(&String.upcase/1)\n256:     |> Enum.uniq()\n257:     |> Enum.sort()\n258:   end\n```\n\n### FUNCTION: `process_list`\n> Signature: `def process_list(items) do`\n> Lines: 251-258\n```\n251:   def process_list(items) do\n252:     items\n253:     |> Enum.map(&String.trim/1)\n254:     |> Enum.reject(&(&1 == \"\"))\n255:     |> Enum.map(&String.upcase/1)\n256:     |> Enum.uniq()\n257:     |> Enum.sort()\n258:   end\n```\n\n### FUNCTION: `pythagorean_triples`\n> Signature: `def pythagorean_triples(range) do`\n> Lines: 267-274\n```\n267:   def pythagorean_triples(range) do\n268:     for a <- 1..range,\n269:         b <- a..range,\n270:         c <- b..range,\n271:         a * a + b * b == c * c do\n272:       {a, b, c}\n273:     end\n274:   end\n```\n\n### FUNCTION: `safe_divide`\n> Signature: `def safe_divide(_, 0), do: {:error, :division_by_zero}`\n> Lines: 284-296\n```\n284:   def safe_divide(_, 0), do: {:error, :division_by_zero}\n285:   def safe_divide(a, b), do: {:ok, a / b}\n287:   @doc \"\"\"\n288:   Recursively compute factorial with guard clause.\n290:   @param n Non-negative integer.\n291:   @return Factorial of n.\n292:   \"\"\"\n293:   @spec factorial(non_neg_integer()) :: pos_integer()\n294:   def factorial(0), do: 1\n295:   def factorial(n) when n > 0, do: n * factorial(n - 1)\n296: end\n```\n\n### FUNCTION: `safe_divide`\n> Signature: `def safe_divide(a, b), do: {:ok, a / b}`\n> Lines: 285-296\n```\n285:   def safe_divide(a, b), do: {:ok, a / b}\n287:   @doc \"\"\"\n288:   Recursively compute factorial with guard clause.\n290:   @param n Non-negative integer.\n291:   @return Factorial of n.\n292:   \"\"\"\n293:   @spec factorial(non_neg_integer()) :: pos_integer()\n294:   def factorial(0), do: 1\n295:   def factorial(n) when n > 0, do: n * factorial(n - 1)\n296: end\n```\n\n### FUNCTION: `factorial`\n> Signature: `def factorial(0), do: 1`\n> Lines: 294-296\n```\n294:   def factorial(0), do: 1\n295:   def factorial(n) when n > 0, do: n * factorial(n - 1)\n296: end\n```\n\n### FUNCTION: `factorial`\n> Signature: `def factorial(n) when n > 0, do: n * factorial(n - 1)`\n> Lines: 295-296\n```\n295:   def factorial(n) when n > 0, do: n * factorial(n - 1)\n296: end\n```\n\n### FUNCTION: `audit`\n> Signature: `def audit(data)`\n> Lines: 340-341\n```\n340:   def audit(data)\n341: end\n```\n\n### FUNCTION: `render`\n> Signature: `def render(data)`\n> Lines: 344-345\n```\n344:   def render(data)\n345: end\n```\n\n### FUNCTION: `parse`\n> Signature: `def parse(data)`\n> Lines: 348-349\n```\n348:   def parse(data)\n349: end\n```\n\n### FUNCTION: `validate`\n> Signature: `def validate(data)`\n> Lines: 352-353\n```\n352:   def validate(data)\n353: end\n```\n\n### FUNCTION: `audit`\n> Signature: `def audit(data), do: data`\n> Lines: 356-357\n```\n356:   def audit(data), do: data\n357: end\n```\n\n### FUNCTION: `render`\n> Signature: `def render(data), do: data`\n> Lines: 360-361\n```\n360:   def render(data), do: data\n361: end\n```\n\n### FUNCTION: `parse`\n> Signature: `def parse(data), do: data`\n> Lines: 364-365\n```\n364:   def parse(data), do: data\n365: end\n```\n\n### FUNCTION: `validate`\n> Signature: `def validate(data), do: data`\n> Lines: 368-369\n```\n368:   def validate(data), do: data\n369: end\n```\n\n### FUNCTION: `req_cover_elixir_1`\n> Signature: `def req_cover_elixir_1(value), do: value + 1`\n> Lines: 378-408\n- @brief Coverage helper construct 1.\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\n378:   def req_cover_elixir_1(value), do: value + 1\n385:   def req_cover_elixir_2(value), do: value + 2\n392:   def req_cover_elixir_3(value), do: value + 3\n399:   def req_cover_elixir_4(value), do: value + 4\n406:   def req_cover_elixir_5(value), do: value + 5\n408: end\n```\n\n### FUNCTION: `req_cover_elixir_2`\n> Signature: `def req_cover_elixir_2(value), do: value + 2`\n> Lines: 385-408\n- @brief Coverage helper construct 2.\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\n385:   def req_cover_elixir_2(value), do: value + 2\n392:   def req_cover_elixir_3(value), do: value + 3\n399:   def req_cover_elixir_4(value), do: value + 4\n406:   def req_cover_elixir_5(value), do: value + 5\n408: end\n```\n\n### FUNCTION: `req_cover_elixir_3`\n> Signature: `def req_cover_elixir_3(value), do: value + 3`\n> Lines: 392-408\n- @brief Coverage helper construct 3.\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\n392:   def req_cover_elixir_3(value), do: value + 3\n399:   def req_cover_elixir_4(value), do: value + 4\n406:   def req_cover_elixir_5(value), do: value + 5\n408: end\n```\n\n### FUNCTION: `req_cover_elixir_4`\n> Signature: `def req_cover_elixir_4(value), do: value + 4`\n> Lines: 399-408\n- @brief Coverage helper construct 4.\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\n399:   def req_cover_elixir_4(value), do: value + 4\n406:   def req_cover_elixir_5(value), do: value + 5\n408: end\n```\n\n### FUNCTION: `req_cover_elixir_5`\n> Signature: `def req_cover_elixir_5(value), do: value + 5`\n> Lines: 406-408\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\n406:   def req_cover_elixir_5(value), do: value + 5\n408: end\n```\n\n@@@ <PROJECT_BASE>/src/fixture_go.go | go\n\n### IMPORT: `(`\n> Lines: 14-14\n```\n14: import (\n```\n\n### FUNCTION: `main`\n> Signature: `func main()`\n> Lines: 111-113\n```\n111: func main() {\n112: \tfmt.Println(\"hello\")\n113: }\n```\n\n### FUNCTION: `init`\n> Signature: `func init()`\n> Lines: 116-119\n```\n116: func init() {\n118: \tglobalVar = 1\n119: }\n```\n\n### FUNCTION: `Divide`\n> Signature: `func Divide(a, b int) (int, int, error)`\n> Lines: 180-185\n- @param a Dividend.\n- @param b Divisor; must not be zero.\n- @return Quotient and remainder, or error if b is zero.\n```\n180: func Divide(a, b int) (int, int, error) {\n181: \tif b == 0 {\n182: \t\treturn 0, 0, fmt.Errorf(\"division by zero\")\n183: \t}\n184: \treturn a / b, a % b, nil\n185: }\n```\n\n### FUNCTION: `ParseConfig`\n> Signature: `func ParseConfig(input string) (host string, port int, err error)`\n> Lines: 192-200\n- @param input Configuration string in \"host:port\" format.\n- @return Named host and port values, or error.\n```\n192: func ParseConfig(input string) (host string, port int, err error) {\n194: \t_, scanErr := fmt.Sscanf(input, \"%s:%d\", &host, &port)\n195: \tif scanErr != nil {\n196: \t\terr = scanErr\n197: \t\treturn\n198: \t}\n199: \treturn\n200: }\n```\n\n### FUNCTION: `Counter`\n> Signature: `func Counter() func() int`\n> Lines: 206-213\n- @return Closure yielding successive integer counts.\n```\n206: func Counter() func() int {\n207: \tcount := 0\n208: \treturn func() int {\n210: \t\tcount++\n211: \t\treturn count\n212: \t}\n213: }\n```\n\n### FUNCTION: `FanOut`\n> Signature: `func FanOut(items []string, workers int) <-chan string`\n> Lines: 221-243\n- @param items Slice of strings to process.\n- @param workers Number of concurrent worker goroutines.\n- @return Channel delivering processed results.\n```\n221: func FanOut(items []string, workers int) <-chan string {\n222: \tresults := make(chan string, len(items))\n223: \tvar wg sync.WaitGroup\n225: \tfor i := 0; i < workers; i++ {\n226: \t\twg.Add(1)\n227: \t\tgo func(id int) {\n228: \t\t\tdefer wg.Done()\n230: \t\t\tfor _, item := range items {\n231: \t\t\t\tresults <- fmt.Sprintf(\"[%d] %s\", id, item)\n232: \t\t\t}\n233: \t\t}(i)\n234: \t}\n237: \tgo func() {\n238: \t\twg.Wait()\n239: \t\tclose(results)\n240: \t}()\n242: \treturn results\n243: }\n```\n\n### FUNCTION: `Describe`\n> Signature: `func Describe(v interface{}) string`\n> Lines: 250-266\n- @param v Any value to describe.\n- @return Human-readable type description.\n```\n250: func Describe(v interface{}) string {\n251: \tswitch val := v.(type) {\n252: \tcase int:\n253: \t\treturn fmt.Sprintf(\"int: %d\", val)\n254: \tcase string:\n255: \t\treturn fmt.Sprintf(\"string: %q\", val)\n256: \tcase bool:\n257: \t\tif val {\n258: \t\t\treturn \"bool: true\"\n259: \t\t}\n260: \t\treturn \"bool: false\"\n261: \tcase nil:\n262: \t\treturn \"nil\"\n263: \tdefault:\n264: \t\treturn fmt.Sprintf(\"unknown: %T\", val)\n265: \t}\n266: }\n```\n\n### FUNCTION: `SafeExecute`\n> Signature: `func SafeExecute(fn func()) (err error)`\n> Lines: 273-282\n- @param fn The function to execute safely.\n- @return Error if fn panicked, nil otherwise.\n```\n273: func SafeExecute(fn func()) (err error) {\n274: \tdefer func() {\n275: \t\tif r := recover(); r != nil {\n277: \t\t\terr = fmt.Errorf(\"panic: %v\", r)\n278: \t\t}\n279: \t}()\n280: \tfn()\n281: \treturn nil\n282: }\n```\n\n### IMPORT: `\"os\"`\n> Lines: 289-289\n```\n289: import \"os\"\n```\n\n### IMPORT: `\"time\"`\n> Lines: 290-290\n```\n290: import \"time\"\n```\n\n### IMPORT: `\"strings\"`\n> Lines: 291-291\n```\n291: import \"strings\"\n```\n\n### IMPORT: `\"bytes\"`\n> Lines: 292-292\n```\n292: import \"bytes\"\n```\n\n### FUNCTION: `reqCoverGo1`\n> Signature: `func reqCoverGo1(value int) int { return value + 1 }`\n> Lines: 311-311\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\n311: func reqCoverGo1(value int) int { return value + 1 }\n```\n\n### FUNCTION: `reqCoverGo2`\n> Signature: `func reqCoverGo2(value int) int { return value + 2 }`\n> Lines: 318-318\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\n318: func reqCoverGo2(value int) int { return value + 2 }\n```\n\n### FUNCTION: `reqCoverGo3`\n> Signature: `func reqCoverGo3(value int) int { return value + 3 }`\n> Lines: 325-325\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\n325: func reqCoverGo3(value int) int { return value + 3 }\n```\n\n### FUNCTION: `reqCoverGo4`\n> Signature: `func reqCoverGo4(value int) int { return value + 4 }`\n> Lines: 332-332\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\n332: func reqCoverGo4(value int) int { return value + 4 }\n```\n\n### FUNCTION: `reqCoverGo5`\n> Signature: `func reqCoverGo5(value int) int { return value + 5 }`\n> Lines: 339-339\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\n339: func reqCoverGo5(value int) int { return value + 5 }\n```\n\n@@@ <PROJECT_BASE>/src/fixture_haskell.hs | haskell\n\n### IMPORT: `Data.List (sort, nub, intercalate)`\n> Lines: 22-22\n```\n22: import Data.List (sort, nub, intercalate)\n```\n\n### IMPORT: `Data.Maybe (fromMaybe, isJust)`\n> Lines: 23-23\n```\n23: import Data.Maybe (fromMaybe, isJust)\n```\n\n### IMPORT: `Data.Map as Map`\n> Lines: 24-24\n```\n24: import qualified Data.Map as Map\n```\n\n### IMPORT: `Control.Monad (when, unless, forM_)`\n> Lines: 25-25\n```\n25: import Control.Monad (when, unless, forM_)\n```\n\n### CLASS: `Printable`\n> Signature: `class Printable a where`\n> Lines: 72-79\n```\n72: class Printable a where\n74:   printIt :: a -> String\n77:   debugPrint :: a -> String\n78:   debugPrint x = \"Debug: \" ++ printIt x\n```\n\n### CLASS: `Serializable`\n> Signature: `class Serializable a where`\n> Lines: 81-84\n```\n81: class Serializable a where\n83:   serialize :: a -> [(String, String)]\n```\n\n### FUNCTION: `greet`\n> Signature: `greet :: String -> String`\n> Lines: 112-112\n```\n112: greet :: String -> String\n```\n\n### FUNCTION: `safeDiv`\n> Signature: `safeDiv :: Double -> Double -> Maybe Double`\n> Lines: 117-117\n```\n117: safeDiv :: Double -> Double -> Maybe Double\n```\n\n### FUNCTION: `eval`\n> Signature: `eval :: Expr -> Double`\n> Lines: 123-123\n```\n123: eval :: Expr -> Double\n```\n\n### FUNCTION: `processList`\n> Signature: `processList :: [Int] -> [Int]`\n> Lines: 131-131\n```\n131: processList :: [Int] -> [Int]\n```\n\n### FUNCTION: `fibonacci`\n> Signature: `fibonacci :: Int -> Integer`\n> Lines: 143-143\n```\n143: fibonacci :: Int -> Integer\n```\n\n### FUNCTION: `insertTree`\n> Signature: `insertTree :: (Ord a) => a -> Tree a -> Tree a`\n> Lines: 155-155\n```\n155: insertTree :: (Ord a) => a -> Tree a -> Tree a\n```\n\n### FUNCTION: `foldTree`\n> Signature: `foldTree :: (b -> a -> b) -> b -> Tree a -> b`\n> Lines: 164-164\n```\n164: foldTree :: (b -> a -> b) -> b -> Tree a -> b\n```\n\n### FUNCTION: `lookupConfig`\n> Signature: `lookupConfig :: Config -> String -> Int -> Int`\n> Lines: 173-173\n```\n173: lookupConfig :: Config -> String -> Int -> Int\n```\n\n### FUNCTION: `applyN`\n> Signature: `applyN :: Int -> Transform a -> a -> a`\n> Lines: 178-178\n```\n178: applyN :: Int -> Transform a -> a -> a\n```\n\n### FUNCTION: `formatPersons`\n> Signature: `formatPersons :: (Printable a) => [a] -> String`\n> Lines: 184-184\n```\n184: formatPersons :: (Printable a) => [a] -> String\n```\n\n### FUNCTION: `safeCompute`\n> Signature: `safeCompute :: Double -> Double -> Double -> Maybe Double`\n> Lines: 189-189\n```\n189: safeCompute :: Double -> Double -> Double -> Maybe Double\n```\n\n### IMPORT: `Data.Set as Set`\n> Lines: 201-201\n```\n201: import qualified Data.Set as Set\n```\n\n### CLASS: `Renderable`\n> Signature: `class Renderable a where`\n> Lines: 204-204\n```\n204: class Renderable a where\n```\n\n### CLASS: `Parsable`\n> Signature: `class Parsable a where`\n> Lines: 205-205\n```\n205: class Parsable a where\n```\n\n### CLASS: `Executable`\n> Signature: `class Executable a where`\n> Lines: 206-206\n```\n206: class Executable a where\n```\n\n### FUNCTION: `reqCoverHaskell1`\n> Signature: `reqCoverHaskell1 :: Int -> Int`\n> Lines: 215-215\n- @brief Coverage helper construct 1.\n--\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n--\n- @param value Input value for helper construct 1.\n--\n- @return Output value for helper construct 1.\n```\n215: reqCoverHaskell1 :: Int -> Int\n```\n\n### FUNCTION: `reqCoverHaskell2`\n> Signature: `reqCoverHaskell2 :: Int -> Int`\n> Lines: 223-223\n- @brief Coverage helper construct 2.\n--\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n--\n- @param value Input value for helper construct 2.\n--\n- @return Output value for helper construct 2.\n```\n223: reqCoverHaskell2 :: Int -> Int\n```\n\n### FUNCTION: `reqCoverHaskell3`\n> Signature: `reqCoverHaskell3 :: Int -> Int`\n> Lines: 231-231\n- @brief Coverage helper construct 3.\n--\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n--\n- @param value Input value for helper construct 3.\n--\n- @return Output value for helper construct 3.\n```\n231: reqCoverHaskell3 :: Int -> Int\n```\n\n### FUNCTION: `reqCoverHaskell4`\n> Signature: `reqCoverHaskell4 :: Int -> Int`\n> Lines: 239-239\n- @brief Coverage helper construct 4.\n--\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n--\n- @param value Input value for helper construct 4.\n--\n- @return Output value for helper construct 4.\n```\n239: reqCoverHaskell4 :: Int -> Int\n```\n\n### FUNCTION: `reqCoverHaskell5`\n> Signature: `reqCoverHaskell5 :: Int -> Int`\n> Lines: 247-247\n- @brief Coverage helper construct 5.\n--\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n--\n- @param value Input value for helper construct 5.\n--\n- @return Output value for helper construct 5.\n```\n247: reqCoverHaskell5 :: Int -> Int\n```\n\n@@@ <PROJECT_BASE>/src/fixture_java.java | java\n- @brief Comprehensive Java test fixture for parser validation.\n- @details Covers generics with wildcards, sealed classes, records, inner classes,\nanonymous classes, lambdas, method references, switch expressions,\ntry-with-resources, annotations, and default interface methods.\n\n### IMPORT: `java.util.List`\n> Lines: 13-13\n```\n13: import java.util.List;\n```\n\n### IMPORT: `java.util.Map`\n> Lines: 14-14\n```\n14: import java.util.Map;\n```\n\n### IMPORT: `java.util.Optional`\n> Lines: 15-15\n```\n15: import java.util.Optional;\n```\n\n### IMPORT: `java.util.function.Function`\n> Lines: 16-16\n```\n16: import java.util.function.Function;\n```\n\n### IMPORT: `java.util.function.Predicate`\n> Lines: 17-17\n```\n17: import java.util.function.Predicate;\n```\n\n### IMPORT: `java.util.stream.Collectors`\n> Lines: 18-18\n```\n18: import java.util.stream.Collectors;\n```\n\n### IMPORT: `java.lang.Math.PI`\n> Lines: 19-19\n```\n19: import static java.lang.Math.PI;\n```\n\n### DECORATOR: `interface`\n> Lines: 27-27\n- @brief Marks a method as requiring authentication before invocation.\n- @param role The minimum role level required for access.\n```\n27: @interface RequiresAuth {\n```\n\n### FUNCTION: `role`\n> Signature: `String role() default \"user\"`\n> Lines: 28-39\n```\n28: String role() default \"user\";\n29: }\n38: @SuppressWarnings(\"unchecked\")\n39: public class MyClass<T extends Comparable<T>> {\n```\n\n### DECORATOR: `SuppressWarnings(\"unchecked\")`\n> Lines: 38-38\n- @brief Primary class demonstrating various Java constructs.\n- @param <T> Generic type parameter for flexible data handling.\n```\n38: @SuppressWarnings(\"unchecked\")\n```\n\n### CLASS: `MyClass`\n> Signature: `public class MyClass<T extends Comparable<T>>`\n> Lines: 39-165\n- @brief Maximum buffer size constant.\n```\n39: public class MyClass<T extends Comparable<T>> {\n42: public static final int MAX_SIZE = 100;\n45: private List<T> items;\n51: public MyClass(List<T> items) {\n52: this.items = items;\n53: }\n59: public void greet(String name) {\n61: if (name == null) {\n62: return;\n63: }\n64: System.out.println(\"Hello, \" + name);\n65: }\n71: private static String helper() {\n72: return \"ok\";\n73: }\n80: public Optional<T> findFirst(Predicate<T> predicate) {\n81: for (T item : items) {\n83: if (predicate.test(item)) {\n84: return Optional.of(item);\n85: }\n86: }\n87: return Optional.empty();\n88: }\n96: public <R> List<R> map(Function<T, R> mapper) {\n97: return items.stream()\n98: .map(mapper)\n99: .collect(Collectors.toList());\n100: }\n107: public double sumWildcard(List<? extends Number> source) {\n108: double total = 0.0;\n109: for (Number n : source) {\n110: total += n.doubleValue();\n111: }\n112: return total;\n113: }\n121: public class Builder {\n122: private List<T> pending;\n129: public Builder add(T item) {\n130: pending.add(item);\n131: return this;\n132: }\n138: public MyClass<T> build() {\n139: return new MyClass<>(pending);\n140: }\n141: }\n149: public static class Config {\n151: public final String key;\n153: public final Object value;\n160: public Config(String key, Object value) {\n161: this.key = key;\n162: this.value = value;\n163: }\n164: }\n165: }\n```\n\n### FUNCTION: `MyClass`\n> Signature: `public MyClass(List<T> items)`\n> Lines: 51-53\n- @brief Construct MyClass with an initial item list.\n- @param items The starting collection of items.\n```\n51: public MyClass(List<T> items) {\n52: this.items = items;\n53: }\n```\n\n### FUNCTION: `greet`\n> Signature: `public void greet(String name)`\n> Lines: 59-65\n- @brief Greet a person by name on standard output.\n- @param name The person's name; must not be null.\n```\n59: public void greet(String name) {\n61: if (name == null) {\n62: return;\n63: }\n64: System.out.println(\"Hello, \" + name);\n65: }\n```\n\n### FUNCTION: `helper`\n> Signature: `private static String helper()`\n> Lines: 71-73\n- @brief Helper method returning a status string.\n- @return Always returns \"ok\".\n```\n71: private static String helper() {\n72: return \"ok\";\n73: }\n```\n\n### FUNCTION: `findFirst`\n> Signature: `public Optional<T> findFirst(Predicate<T> predicate)`\n> Lines: 80-88\n- @brief Find the first item matching a predicate.\n- @param predicate Filter condition for items.\n- @return Optional containing the first match, or empty.\n```\n80: public Optional<T> findFirst(Predicate<T> predicate) {\n81: for (T item : items) {\n83: if (predicate.test(item)) {\n84: return Optional.of(item);\n85: }\n86: }\n87: return Optional.empty();\n88: }\n```\n\n### FUNCTION: `map`\n> Signature: `public <R> List<R> map(Function<T, R> mapper)`\n> Lines: 96-100\n- @brief Transform all items using a mapping function.\n- @param <R> The result type after transformation.\n- @param mapper Function to apply to each item.\n- @return List of transformed results.\n```\n96: public <R> List<R> map(Function<T, R> mapper) {\n97: return items.stream()\n98: .map(mapper)\n99: .collect(Collectors.toList());\n100: }\n```\n\n### FUNCTION: `sumWildcard`\n> Signature: `public double sumWildcard(List<? extends Number> source)`\n> Lines: 107-113\n- @brief Process items with a wildcard-bounded list.\n- @param source List of items extending Number.\n- @return Sum of all numeric values as double.\n```\n107: public double sumWildcard(List<? extends Number> source) {\n108: double total = 0.0;\n109: for (Number n : source) {\n110: total += n.doubleValue();\n111: }\n112: return total;\n113: }\n```\n\n### CLASS: `Builder`\n> Signature: `public class Builder`\n> Lines: 121-141\n- @brief Inner builder class for constructing MyClass instances.\n- @brief Add an item to the builder.\n- @param item Item to include in the built instance.\n- @return This builder for chaining.\n```\n121: public class Builder {\n122: private List<T> pending;\n129: public Builder add(T item) {\n130: pending.add(item);\n131: return this;\n132: }\n138: public MyClass<T> build() {\n139: return new MyClass<>(pending);\n140: }\n141: }\n```\n\n### FUNCTION: `add`\n> Signature: `public Builder add(T item)`\n> Lines: 129-132\n- @brief Add an item to the builder.\n- @param item Item to include in the built instance.\n- @return This builder for chaining.\n```\n129: public Builder add(T item) {\n130: pending.add(item);\n131: return this;\n132: }\n```\n\n### FUNCTION: `build`\n> Signature: `public MyClass<T> build()`\n> Lines: 138-140\n- @brief Finalize and create the MyClass instance.\n- @return A new MyClass populated with accumulated items.\n```\n138: public MyClass<T> build() {\n139: return new MyClass<>(pending);\n140: }\n```\n\n### CLASS: `Config`\n> Signature: `public static class Config`\n> Lines: 149-164\n- @brief Static configuration holder with validation.\n- @brief Configuration key string.\n- @brief Configuration value.\n```\n149: public static class Config {\n151: public final String key;\n153: public final Object value;\n160: public Config(String key, Object value) {\n161: this.key = key;\n162: this.value = value;\n163: }\n164: }\n```\n\n### FUNCTION: `Config`\n> Signature: `public Config(String key, Object value)`\n> Lines: 160-163\n- @brief Construct a Config entry.\n- @param key The configuration key.\n- @param value The associated value.\n```\n160: public Config(String key, Object value) {\n161: this.key = key;\n162: this.value = value;\n163: }\n```\n\n### FUNCTION: `sayHello`\n> Signature: `void sayHello(String name)`\n> Lines: 178-186\n- @brief Perform a greeting to the named person.\n- @brief Default farewell method with implementation.\n- @param name Recipient of the greeting.\n- @param name Person to bid farewell.\n```\n178: void sayHello(String name);\n184: default void sayGoodbye(String name) {\n185: System.out.println(\"Goodbye, \" + name);\n186: }\n```\n\n### FUNCTION: `simple`\n> Signature: `static Greeter simple()`\n> Lines: 192-195\n- @brief Static factory creating a simple Greeter.\n- @return A Greeter that prints to stdout.\n```\n192: static Greeter simple() {\n194: return name -> System.out.println(\"Hi, \" + name);\n195: }\n```\n\n### FUNCTION: `getHex`\n> Signature: `public String getHex()`\n> Lines: 227-229\n- @brief Get the hex code of this color.\n- @return Hex string including '#' prefix.\n```\n227: public String getHex() {\n228: return hex;\n229: }\n```\n\n### FUNCTION: `Point`\n> Signature: `public record Point(double x, double y)`\n> Lines: 240-261\n- @brief Immutable 2D coordinate record.\n- @brief Compact constructor validating coordinates.\n- @param x Horizontal coordinate.\n- @param y Vertical coordinate.\n- @throws IllegalArgumentException If either coordinate is NaN.\n```\n240: public record Point(double x, double y) {\n245: public Point {\n246: if (Double.isNaN(x) || Double.isNaN(y)) {\n247: throw new IllegalArgumentException(\"NaN coordinates\");\n248: }\n249: }\n256: public double distanceTo(Point other) {\n257: double dx = this.x - other.x;\n258: double dy = this.y - other.y;\n259: return Math.sqrt(dx * dx + dy * dy);\n260: }\n261: }\n```\n\n### FUNCTION: `distanceTo`\n> Signature: `public double distanceTo(Point other)`\n> Lines: 256-260\n- @brief Compute distance to another point.\n- @param other Target point.\n- @return Euclidean distance.\n```\n256: public double distanceTo(Point other) {\n257: double dx = this.x - other.x;\n258: double dy = this.y - other.y;\n259: return Math.sqrt(dx * dx + dy * dy);\n260: }\n```\n\n### FUNCTION: `area`\n> Signature: `public double area()`\n> Lines: 274-276\n- @brief Compute the area of this shape.\n- @return Area as a double; subclasses provide implementation.\n```\n274: public double area() {\n275: return 0.0;\n276: }\n```\n\n### CLASS: `Circle`\n> Signature: `public final class Circle extends Shape`\n> Lines: 284-304\n- @brief Circle shape with radius-based area computation.\n- @brief Radius of the circle.\n```\n284: public final class Circle extends Shape {\n286: private final double radius;\n292: public Circle(double radius) {\n293: this.radius = radius;\n294: }\n300: @Override\n301: public double area() {\n302: return PI * radius * radius;\n303: }\n304: }\n```\n\n### FUNCTION: `Circle`\n> Signature: `public Circle(double radius)`\n> Lines: 292-294\n- @brief Construct a circle with a given radius.\n- @param radius Non-negative radius value.\n```\n292: public Circle(double radius) {\n293: this.radius = radius;\n294: }\n```\n\n### DECORATOR: `Override`\n> Lines: 300-300\n- @brief Compute circle area using π×r².\n- @return The area of the circle.\n```\n300: @Override\n```\n\n### FUNCTION: `area`\n> Signature: `public double area()`\n> Lines: 301-303\n```\n301: public double area() {\n302: return PI * radius * radius;\n303: }\n```\n\n### CLASS: `Rectangle`\n> Signature: `public final class Rectangle extends Shape`\n> Lines: 311-324\n- @brief Rectangle shape with width and height.\n```\n311: public final class Rectangle extends Shape {\n312: private final double width;\n313: private final double height;\n315: public Rectangle(double width, double height) {\n316: this.width = width;\n317: this.height = height;\n318: }\n320: @Override\n321: public double area() {\n322: return width * height;\n323: }\n324: }\n```\n\n### FUNCTION: `Rectangle`\n> Signature: `public Rectangle(double width, double height)`\n> Lines: 315-318\n```\n315: public Rectangle(double width, double height) {\n316: this.width = width;\n317: this.height = height;\n318: }\n```\n\n### DECORATOR: `Override`\n> Lines: 320-320\n```\n320: @Override\n```\n\n### FUNCTION: `area`\n> Signature: `public double area()`\n> Lines: 321-323\n```\n321: public double area() {\n322: return width * height;\n323: }\n```\n\n### CLASS: `Evaluator`\n> Signature: `public class Evaluator`\n> Lines: 332-361\n- @brief Demonstrates switch expressions and try-with-resources.\n- @brief Describe a shape using pattern matching switch expression.\n- @param shape The shape to describe.\n- @return Human-readable description string.\n```\n332: public class Evaluator {\n339: public static String describe(Shape shape) {\n341: return switch (shape) {\n342: case Circle c -> \"Circle with radius \" + c.area();\n343: case Rectangle r -> \"Rectangle with area \" + r.area();\n344: default -> \"Unknown shape\";\n345: };\n346: }\n354: @RequiresAuth(role = \"admin\")\n355: public static String readFile(String path) throws java.io.IOException {\n357: try (var reader = new java.io.BufferedReader(new java.io.FileReader(path))) {\n358: return reader.lines().collect(Collectors.joining(\"\\n\"));\n359: }\n360: }\n361: }\n```\n\n### FUNCTION: `describe`\n> Signature: `public static String describe(Shape shape)`\n> Lines: 339-346\n- @brief Describe a shape using pattern matching switch expression.\n- @param shape The shape to describe.\n- @return Human-readable description string.\n```\n339: public static String describe(Shape shape) {\n341: return switch (shape) {\n342: case Circle c -> \"Circle with radius \" + c.area();\n343: case Rectangle r -> \"Rectangle with area \" + r.area();\n344: default -> \"Unknown shape\";\n345: };\n346: }\n```\n\n### FUNCTION: `switch`\n> Signature: `return switch (shape)`\n> Lines: 341-345\n```\n341: return switch (shape) {\n342: case Circle c -> \"Circle with radius \" + c.area();\n343: case Rectangle r -> \"Rectangle with area \" + r.area();\n344: default -> \"Unknown shape\";\n345: };\n```\n\n### DECORATOR: `RequiresAuth(role = \"admin\")`\n> Lines: 354-354\n- @brief Read a file safely with try-with-resources.\n- @param path File system path to read.\n- @return File contents as a string.\n- @throws java.io.IOException If the file cannot be read.\n```\n354: @RequiresAuth(role = \"admin\")\n```\n\n### FUNCTION: `readFile`\n> Signature: `public static String readFile(String path) throws java.io.IOException`\n> Lines: 355-360\n```\n355: public static String readFile(String path) throws java.io.IOException {\n357: try (var reader = new java.io.BufferedReader(new java.io.FileReader(path))) {\n358: return reader.lines().collect(Collectors.joining(\"\\n\"));\n359: }\n360: }\n```\n\n### DECORATOR: `Trace`\n> Lines: 380-380\n```\n380: @Trace\n```\n\n### CLASS: `ReqCoverJava`\n> Signature: `class ReqCoverJava`\n> Lines: 383-429\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\n383: class ReqCoverJava {\n391: static int reqCoverJava1(int value) { return value + 1; }\n400: static int reqCoverJava2(int value) { return value + 2; }\n409: static int reqCoverJava3(int value) { return value + 3; }\n418: static int reqCoverJava4(int value) { return value + 4; }\n427: static int reqCoverJava5(int value) { return value + 5; }\n429: }\n```\n\n### FUNCTION: `reqCoverJava1`\n> Signature: `static int reqCoverJava1(int value) { return value + 1; }`\n> Lines: 391-391\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\n391: static int reqCoverJava1(int value) { return value + 1; }\n```\n\n### FUNCTION: `reqCoverJava2`\n> Signature: `static int reqCoverJava2(int value) { return value + 2; }`\n> Lines: 400-400\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\n400: static int reqCoverJava2(int value) { return value + 2; }\n```\n\n### FUNCTION: `reqCoverJava3`\n> Signature: `static int reqCoverJava3(int value) { return value + 3; }`\n> Lines: 409-409\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\n409: static int reqCoverJava3(int value) { return value + 3; }\n```\n\n### FUNCTION: `reqCoverJava4`\n> Signature: `static int reqCoverJava4(int value) { return value + 4; }`\n> Lines: 418-418\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\n418: static int reqCoverJava4(int value) { return value + 4; }\n```\n\n### FUNCTION: `reqCoverJava5`\n> Signature: `static int reqCoverJava5(int value) { return value + 5; }`\n> Lines: 427-427\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\n427: static int reqCoverJava5(int value) { return value + 5; }\n```\n\n@@@ <PROJECT_BASE>/src/fixture_javascript.js | javascript\n- @brief Comprehensive JavaScript test fixture for parser validation.\n- @details Covers classes with private fields, generators, async generators,\nproxies, symbols, IIFE, dynamic imports, destructuring, computed\nproperties, and chained promise patterns.\n\n### IMPORT: `React from 'react';`\n> Lines: 11-11\n```\n11: import React from 'react';\n```\n\n### IMPORT: `{ useState, useEffect } from 'react';`\n> Lines: 12-12\n```\n12: import { useState, useEffect } from 'react';\n```\n\n### CLASS: `MyComponent`\n> Signature: `class MyComponent`\n> Lines: 20-66\n- @brief React-like component with private fields and static initialization.\n- @brief Private instance counter, not accessible outside the class.\n```\n20: class MyComponent {\n22: #instanceId;\n25: static #registry = new Map();\n28: static {\n29: console.log('MyComponent class loaded');\n30: }\n36: constructor(id = 0) {\n37: this.#instanceId = id;\n38: MyComponent.#registry.set(id, this);\n39: }\n45: render() {\n47: return null;\n48: }\n54: getId() {\n55: return this.#instanceId;\n56: }\n63: static has(id) {\n64: return MyComponent.#registry.has(id);\n65: }\n66: }\n```\n\n### CLASS: `EnhancedComponent`\n> Signature: `class EnhancedComponent extends MyComponent`\n> Lines: 75-93\n- @brief Extended component with lifecycle hooks.\n- @brief Override render to return a div element.\n- @return {Object} A simple virtual DOM node.\n```\n75: class EnhancedComponent extends MyComponent {\n80: render() {\n82: super.render();\n83: return { type: 'div', children: [] };\n84: }\n90: componentDidMount() {\n91: console.log('mounted');\n92: }\n93: }\n```\n\n### FUNCTION: `greet`\n> Signature: `function greet(name)`\n> Lines: 103-105\n- @brief Greet a person by name.\n- @param {string} name The person's name.\n- @return {string} Greeting message.\n```\n103: function greet(name) {\n104: return \"Hello \" + name;\n105: }\n```\n\n### FUNCTION: `fetchData`\n> Signature: `async function fetchData()`\n> Lines: 112-115\n- @brief Fetch data from the API endpoint asynchronously.\n- @return {Promise<Response>} The fetch response promise.\n```\n112: async function fetchData() {\n114: return await fetch('/api');\n115: }\n```\n\n### FUNCTION: `handler`\n> Signature: `const handler = (event) =>`\n> Lines: 122-126\n- @brief Event handler arrow function for UI events.\n- @param {Event} event The DOM event object.\n```\n122: const handler = (event) => {\n124: event.preventDefault();\n125: console.log(event.type);\n126: };\n```\n\n### FUNCTION: `processItems`\n> Signature: `const processItems = ({ items, count }) =>`\n> Lines: 134-136\n- @brief Arrow function with destructuring parameter.\n- @param {{ items: Array, count: number }} param0 Destructured config.\n- @return {Array} Processed item list.\n```\n134: const processItems = ({ items, count }) => {\n135: return items.slice(0, count).map(i => i.toUpperCase());\n136: };\n```\n\n### FUNCTION: `idGenerator`\n> Signature: `function* idGenerator()`\n> Lines: 164-170\n- @brief Infinite generator producing sequential integer IDs.\n@yields {number} The next unique ID.\n```\n164: function* idGenerator() {\n165: let id = 0;\n166: while (true) {\n168: yield id++;\n169: }\n170: }\n```\n\n### FUNCTION: `rangeGenerator`\n> Signature: `function* rangeGenerator(start, end)`\n> Lines: 179-183\n- @brief Generator yielding integers in a bounded range.\n- @param {number} start Inclusive lower bound.\n- @param {number} end Exclusive upper bound.\n@yields {number} Each integer from start to end-1.\n```\n179: function* rangeGenerator(start, end) {\n180: for (let i = start; i < end; i++) {\n181: yield i;\n182: }\n183: }\n```\n\n### FUNCTION: `asyncDataStream`\n> Signature: `async function* asyncDataStream(url)`\n> Lines: 194-206\n- @brief Asynchronously yield paginated API results.\n- @param {string} url Base URL for pagination.\n@yields {Object} Each page's parsed JSON data.\n```\n194: async function* asyncDataStream(url) {\n195: let page = 0;\n196: while (true) {\n197: const response = await fetch(`${url}?page=${page}`);\n198: const data = await response.json();\n199: if (data.length === 0) {\n201: return;\n202: }\n203: yield data;\n204: page++;\n205: }\n206: }\n```\n\n### FUNCTION: `initResult`\n> Signature: `const initResult = (() =>`\n> Lines: 213-217\n- @brief Immediately invoked function expression for module initialization.\n```\n213: const initResult = (() => {\n215: const config = { debug: false };\n216: return Object.freeze(config);\n217: })();\n```\n\n### FUNCTION: `createProxy`\n> Signature: `function createProxy(target)`\n> Lines: 227-240\n- @brief Create a logging proxy around any target object.\n- @param {Object} target The object to wrap with proxy traps.\n- @return {Proxy} Proxied object that logs property access.\n```\n227: function createProxy(target) {\n228: return new Proxy(target, {\n229: get(obj, prop) {\n231: console.log(`Access: ${String(prop)}`);\n232: return Reflect.get(obj, prop);\n233: },\n234: set(obj, prop, value) {\n236: console.log(`Set: ${String(prop)} = ${value}`);\n237: return Reflect.set(obj, prop, value);\n238: },\n239: });\n240: }\n```\n\n### FUNCTION: `buildDynamic`\n> Signature: `function buildDynamic(prefix)`\n> Lines: 250-258\n- @brief Build an object with computed property keys.\n- @param {string} prefix Key prefix for dynamic properties.\n- @return {Object} Object with dynamically named properties.\n```\n250: function buildDynamic(prefix) {\n251: return {\n252: [`${prefix}_name`]: 'value',\n253: [`${prefix}_id`]: 42,\n254: [Symbol.toPrimitive](hint) {\n255: return hint === 'string' ? prefix : 0;\n256: },\n257: };\n258: }\n```\n\n### FUNCTION: `fetchAndProcess`\n> Signature: `function fetchAndProcess(url)`\n> Lines: 268-280\n- @brief Demonstrate chained promise pattern with error recovery.\n- @param {string} url The resource URL to fetch.\n- @return {Promise<Object>} Processed data or fallback on error.\n```\n268: function fetchAndProcess(url) {\n269: return fetch(url)\n270: .then(res => res.json())\n271: .then(data => {\n273: return { ...data, processed: true };\n274: })\n275: .catch(err => {\n277: console.error(err);\n278: return { error: true, processed: false };\n279: });\n280: }\n```\n\n### FUNCTION: `configureApp`\n> Signature: `function configureApp({ host = 'localhost', port = 3000, db: { url: dbUrl = 'sqlite://' } = {} } = {})`\n> Lines: 290-292\n- @brief Configure application with deep destructuring defaults.\n- @param {Object} options Configuration object with nested defaults.\n- @return {Object} Resolved configuration.\n```\n290: function configureApp({ host = 'localhost', port = 3000, db: { url: dbUrl = 'sqlite://' } = {} } = {}) {\n291: return { host, port, dbUrl };\n292: }\n```\n\n### FUNCTION: `setPrivate`\n> Signature: `function setPrivate(obj, data)`\n> Lines: 310-312\n- @brief Store private data associated with an object.\n- @param {Object} obj The key object.\n- @param {*} data The private data to associate.\n```\n310: function setPrivate(obj, data) {\n311: _privateState.set(obj, data);\n312: }\n```\n\n### FUNCTION: `loadPlugin`\n> Signature: `async function loadPlugin(name)`\n> Lines: 322-326\n- @brief Dynamically import a module at runtime.\n- @param {string} name Module specifier to import.\n- @return {Promise<Module>} The loaded module namespace.\n```\n322: async function loadPlugin(name) {\n324: const mod = await import(`./${name}.js`);\n325: return mod;\n326: }\n```\n\n### IMPORT: `fs from 'fs';`\n> Lines: 329-329\n```\n329: import fs from 'fs';\n```\n\n### IMPORT: `path from 'path';`\n> Lines: 330-330\n```\n330: import path from 'path';\n```\n\n### IMPORT: `url from 'url';`\n> Lines: 331-331\n```\n331: import url from 'url';\n```\n\n### CLASS: `ExtraService`\n> Signature: `export class ExtraService { constructor() { this.ready = true; } }`\n> Lines: 332-332\n```\n332: export class ExtraService { constructor() { this.ready = true; } }\n```\n\n### CLASS: `HelperComponent`\n> Signature: `class HelperComponent { render() { return null; } }`\n> Lines: 333-333\n```\n333: class HelperComponent { render() { return null; } }\n```\n\n### CLASS: `WidgetFactory`\n> Signature: `export default class WidgetFactory { create() { return {}; } }`\n> Lines: 334-334\n```\n334: export default class WidgetFactory { create() { return {}; } }\n```\n\n### FUNCTION: `reqCoverJs1`\n> Signature: `function reqCoverJs1(value) { return value + 1; }`\n> Lines: 353-353\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\n353: function reqCoverJs1(value) { return value + 1; }\n```\n\n### FUNCTION: `reqCoverJs2`\n> Signature: `function reqCoverJs2(value) { return value + 2; }`\n> Lines: 360-360\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\n360: function reqCoverJs2(value) { return value + 2; }\n```\n\n### FUNCTION: `reqCoverJs3`\n> Signature: `function reqCoverJs3(value) { return value + 3; }`\n> Lines: 367-367\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\n367: function reqCoverJs3(value) { return value + 3; }\n```\n\n### FUNCTION: `reqCoverJs4`\n> Signature: `function reqCoverJs4(value) { return value + 4; }`\n> Lines: 374-374\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\n374: function reqCoverJs4(value) { return value + 4; }\n```\n\n### FUNCTION: `reqCoverJs5`\n> Signature: `function reqCoverJs5(value) { return value + 5; }`\n> Lines: 381-381\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\n381: function reqCoverJs5(value) { return value + 5; }\n```\n\n@@@ <PROJECT_BASE>/src/fixture_kotlin.kt | kotlin\n- @brief Comprehensive Kotlin test fixture for parser validation.\n- @details Covers extension functions, inline/reified generics, DSL builders,\ndelegation, coroutine scope, destructuring, sealed interfaces,\nvalue classes, operator overloading, and lateinit.\n\n### IMPORT: `kotlin.collections.List`\n> Lines: 11-11\n```\n11: import kotlin.collections.List\n```\n\n### IMPORT: `kotlinx.coroutines.flow.Flow`\n> Lines: 12-12\n```\n12: import kotlinx.coroutines.flow.Flow\n```\n\n### IMPORT: `kotlinx.coroutines.flow.flow`\n> Lines: 13-13\n```\n13: import kotlinx.coroutines.flow.flow\n```\n\n### DECORATOR: `Deprecated`\n> Lines: 18-18\n- @brief Marks a class or function as deprecated with migration path. */\n```\n18: @Deprecated(\"Use UserV2 instead\", replaceWith = ReplaceWith(\"UserV2\"))\n```\n\n### CLASS: `User`\n> Signature: `data class User(val name: String, val age: Int = 0)`\n> Lines: 19-61\n```\n19: data class User(val name: String, val age: Int = 0)\n28: sealed class Result<out T> {\n34: data class Success<T>(val value: T) : Result<T>()\n42: data class Error(val message: String, val cause: Throwable? = null) : Result<Nothing>()\n48: object Loading : Result<Nothing>()\n56: fun <R> map(transform: (T) -> R): Result<R> = when (this) {\n57: is Success -> Success(transform(value))\n58: is Error -> Error(message, cause)\n59: is Loading -> Loading\n60: }\n61: }\n```\n\n### CLASS: `Result`\n> Signature: `sealed class Result<out T>`\n> Lines: 28-61\n- @brief Sealed class representing success/failure outcomes.\n@tparam T The success value type.\n- @brief Successful outcome holding a value.\n- @param value The result data.\n```\n28: sealed class Result<out T> {\n34: data class Success<T>(val value: T) : Result<T>()\n42: data class Error(val message: String, val cause: Throwable? = null) : Result<Nothing>()\n48: object Loading : Result<Nothing>()\n56: fun <R> map(transform: (T) -> R): Result<R> = when (this) {\n57: is Success -> Success(transform(value))\n58: is Error -> Error(message, cause)\n59: is Loading -> Loading\n60: }\n61: }\n```\n\n### CLASS: `Success`\n> Signature: `data class Success<T>(val value: T) : Result<T>()`\n> Lines: 34-60\n- @brief Successful outcome holding a value.\n- @brief Failed outcome holding an error message.\n- @param value The result data.\n- @param message Description of the failure.\n- @param cause Optional underlying exception.\n```\n34: data class Success<T>(val value: T) : Result<T>()\n42: data class Error(val message: String, val cause: Throwable? = null) : Result<Nothing>()\n48: object Loading : Result<Nothing>()\n56: fun <R> map(transform: (T) -> R): Result<R> = when (this) {\n57: is Success -> Success(transform(value))\n58: is Error -> Error(message, cause)\n59: is Loading -> Loading\n60: }\n```\n\n### CLASS: `Error`\n> Signature: `data class Error(val message: String, val cause: Throwable? = null) : Result<Nothing>()`\n> Lines: 42-60\n- @brief Failed outcome holding an error message.\n- @brief Singleton state representing an in-progress operation.\n- @param message Description of the failure.\n- @param cause Optional underlying exception.\n```\n42: data class Error(val message: String, val cause: Throwable? = null) : Result<Nothing>()\n48: object Loading : Result<Nothing>()\n56: fun <R> map(transform: (T) -> R): Result<R> = when (this) {\n57: is Success -> Success(transform(value))\n58: is Error -> Error(message, cause)\n59: is Loading -> Loading\n60: }\n```\n\n### FUNCTION: `map`\n> Signature: `fun <R> map(transform: (T) -> R): Result<R> = when (this)`\n> Lines: 56-60\n- @brief Map the success value using a transform function.\n@tparam R The target type after transformation.\n- @param transform Function converting T to R.\n- @return Transformed Result or original error/loading state.\n```\n56: fun <R> map(transform: (T) -> R): Result<R> = when (this) {\n57: is Success -> Success(transform(value))\n58: is Error -> Error(message, cause)\n59: is Loading -> Loading\n60: }\n```\n\n### FUNCTION: `findById`\n> Signature: `fun findById(id: Int): T?`\n> Lines: 76-96\n- @brief Find an entity by its unique identifier.\n- @brief Persist an entity.\n- @param id Entity ID.\n- @param entity The entity to save.\n- @return The entity or null if not found.\n- @return True if save succeeded.\n```\n76: fun findById(id: Int): T?\n83: fun save(entity: T): Boolean\n89: fun findAll(): Flow<T>\n90: }\n96: sealed interface Identifiable {\n```\n\n### FUNCTION: `save`\n> Signature: `fun save(entity: T): Boolean`\n> Lines: 83-96\n- @brief Persist an entity.\n- @brief Retrieve all entities as a Flow stream.\n- @param entity The entity to save.\n- @return True if save succeeded.\n- @return Flow emitting all stored entities.\n```\n83: fun save(entity: T): Boolean\n89: fun findAll(): Flow<T>\n90: }\n96: sealed interface Identifiable {\n```\n\n### FUNCTION: `findAll`\n> Signature: `fun findAll(): Flow<T>`\n> Lines: 89-96\n- @brief Retrieve all entities as a Flow stream.\n- @brief Sealed interface requiring an ID property.\n- @return Flow emitting all stored entities.\n```\n89: fun findAll(): Flow<T>\n90: }\n96: sealed interface Identifiable {\n```\n\n### FUNCTION: `fromHex`\n> Signature: `fun fromHex(hex: String): Color? = values().find { it.hex == hex }`\n> Lines: 121-121\n- @brief Parse a color from its hex string.\n- @param hex Hex color code including '#' prefix.\n- @return Matching Color or null.\n```\n121: fun fromHex(hex: String): Color? = values().find { it.hex == hex }\n```\n\n### CLASS: `Entity`\n> Signature: `data class Entity(`\n> Lines: 134-155\n- @brief Data class combining Identifiable with named properties.\n- @param id Unique identifier.\n- @param name Entity display name.\n- @param status Current lifecycle status.\n```\n134: data class Entity(\n135: override val id: Int,\n136: val name: String,\n137: val status: String = \"active\",\n138: ) : Identifiable\n147: @JvmInline\n148: value class EmailAddress(val value: String) {\n149: init {\n150: require(value.contains('@')) { \"Invalid email: $value\" }\n151: }\n154: val domain: String get() = value.substringAfter('@')\n155: }\n```\n\n### DECORATOR: `JvmInline`\n> Lines: 147-147\n- @brief Inline value class wrapping a validated email string.\n- @param value The raw email address string.\n```\n147: @JvmInline\n```\n\n### FUNCTION: `greet`\n> Signature: `fun greet(name: String): String`\n> Lines: 165-167\n- @brief Greet a person by name.\n- @param name The person's name.\n- @return Greeting message string.\n```\n165: fun greet(name: String): String {\n166: return \"Hello $name\"\n167: }\n```\n\n### FUNCTION: `fetchData`\n> Signature: `suspend fun fetchData(): String`\n> Lines: 174-177\n- @brief Suspend function simulating async data retrieval.\n- @return Retrieved data as a string.\n```\n174: suspend fun fetchData(): String {\n176: return \"data\"\n177: }\n```\n\n### FUNCTION: `processItems`\n> Signature: `fun processItems(items: List<String>, transform: (String) -> String): List<String>`\n> Lines: 186-188\n- @brief Higher-order function with trailing lambda syntax.\n- @param items List of strings to process.\n- @param transform Function applied to each item.\n- @return List of transformed results.\n```\n186: fun processItems(items: List<String>, transform: (String) -> String): List<String> {\n187: return items.map(transform)\n188: }\n```\n\n### CLASS: `Vector2`\n> Signature: `data class Vector2(val x: Double, val y: Double)`\n> Lines: 229-249\n- @brief 2D vector with operator overloading for arithmetic.\n- @brief Add two vectors component-wise.\n- @param x Horizontal component.\n- @param y Vertical component.\n- @param other The vector to add.\n- @return Resulting sum vector.\n```\n229: data class Vector2(val x: Double, val y: Double) {\n235: operator fun plus(other: Vector2) = Vector2(x + other.x, y + other.y)\n241: operator fun unaryMinus() = Vector2(-x, -y)\n248: operator fun times(other: Vector2) = x * other.x + y * other.y\n249: }\n```\n\n### VARIABLE: `counter`\n> Signature: `var counter = 0`\n> Lines: 257-257\n- @brief Mutable package-level counter. */\n```\n257: var counter = 0\n```\n\n### FUNCTION: `set`\n> Signature: `fun set(key: String, value: Any)`\n> Lines: 274-276\n- @brief Store a configuration value.\n- @param key Configuration key.\n- @param value Configuration value.\n```\n274: fun set(key: String, value: Any) {\n275: config[key] = value\n276: }\n```\n\n### DECORATOR: `Suppress`\n> Lines: 284-284\n- @brief Retrieve a typed configuration value.\n@tparam T Expected value type.\n- @param key Configuration key.\n- @return The value cast to T, or null.\n```\n284: @Suppress(\"UNCHECKED_CAST\")\n```\n\n### FUNCTION: `get`\n> Signature: `fun <T> get(key: String): T? = config[key] as? T`\n> Lines: 285-292\n- @brief Companion object pattern for factory construction.\n```\n285: fun <T> get(key: String): T? = config[key] as? T\n286: }\n292: companion object Factory {\n```\n\n### CLASS: `DelegatingList`\n> Signature: `class DelegatingList<T>(private val inner: MutableList<T>) : List<T> by inner`\n> Lines: 303-316\n- @brief List implementation delegating to an inner mutable list.\n@tparam T Element type.\n- @brief Count of accesses to the delegated list.\n- @param inner The backing list.\n```\n303: class DelegatingList<T>(private val inner: MutableList<T>) : List<T> by inner {\n305: var accessCount = 0\n306: private set\n311: override val size: Int\n312: get() {\n313: accessCount++\n314: return inner.size\n315: }\n316: }\n```\n\n### VARIABLE: `accessCount`\n> Signature: `var accessCount = 0`\n> Lines: 305-305\n- @brief Count of accesses to the delegated list. */\n```\n305: var accessCount = 0\n```\n\n### CLASS: `Service`\n> Signature: `class Service`\n> Lines: 324-339\n- @brief Service class demonstrating lateinit and lazy initialization.\n- @brief Late-initialized dependency, set after construction.\n```\n324: class Service {\n326: lateinit var dependency: Repository<Entity>\n329: val resource: String by lazy {\n331: \"expensive_resource\"\n332: }\n338: fun isReady(): Boolean = ::dependency.isInitialized\n339: }\n```\n\n### FUNCTION: `isReady`\n> Signature: `fun isReady(): Boolean = ::dependency.isInitialized`\n> Lines: 338-347\n- @brief Check if the dependency has been initialized.\n- @return True if dependency is set.\n```\n338: fun isReady(): Boolean = ::dependency.isInitialized\n339: }\n347: class HtmlBuilder {\n```\n\n### CLASS: `HtmlBuilder`\n> Signature: `class HtmlBuilder`\n> Lines: 347-373\n- @brief Simple DSL for building HTML strings.\n- @brief Add a div element with content from a lambda.\n- @param block Lambda providing the div content.\n```\n347: class HtmlBuilder {\n348: private val elements = mutableListOf<String>()\n354: fun div(block: HtmlBuilder.() -> Unit) {\n355: val inner = HtmlBuilder()\n356: inner.block()\n357: elements.add(\"<div>${inner.build()}</div>\")\n358: }\n364: fun text(text: String) {\n365: elements.add(text)\n366: }\n372: fun build(): String = elements.joinToString(\"\")\n373: }\n```\n\n### FUNCTION: `div`\n> Signature: `fun div(block: HtmlBuilder.() -> Unit)`\n> Lines: 354-358\n- @brief Add a div element with content from a lambda.\n- @param block Lambda providing the div content.\n```\n354: fun div(block: HtmlBuilder.() -> Unit) {\n355: val inner = HtmlBuilder()\n356: inner.block()\n357: elements.add(\"<div>${inner.build()}</div>\")\n358: }\n```\n\n### FUNCTION: `text`\n> Signature: `fun text(text: String)`\n> Lines: 364-366\n- @brief Add a text node.\n- @param text The text content.\n```\n364: fun text(text: String) {\n365: elements.add(text)\n366: }\n```\n\n### FUNCTION: `build`\n> Signature: `fun build(): String = elements.joinToString(\"\")`\n> Lines: 372-381\n- @brief Build the accumulated HTML string.\n- @brief DSL entry point for building HTML content.\n- @param block Builder lambda receiving HtmlBuilder scope.\n- @return Concatenated HTML output.\n- @return Complete HTML string.\n```\n372: fun build(): String = elements.joinToString(\"\")\n373: }\n381: fun html(block: HtmlBuilder.() -> Unit): String {\n```\n\n### FUNCTION: `html`\n> Signature: `fun html(block: HtmlBuilder.() -> Unit): String`\n> Lines: 381-385\n- @brief DSL entry point for building HTML content.\n- @param block Builder lambda receiving HtmlBuilder scope.\n- @return Complete HTML string.\n```\n381: fun html(block: HtmlBuilder.() -> Unit): String {\n382: val builder = HtmlBuilder()\n383: builder.block()\n384: return builder.build()\n385: }\n```\n\n### IMPORT: `kotlin.math.max`\n> Lines: 388-388\n```\n388: import kotlin.math.max\n```\n\n### IMPORT: `kotlin.math.min`\n> Lines: 389-389\n```\n389: import kotlin.math.min\n```\n\n### DECORATOR: `Synchronized`\n> Lines: 398-398\n```\n398: @Synchronized\n```\n\n### DECORATOR: `PublishedApi`\n> Lines: 399-399\n```\n399: @PublishedApi\n```\n\n### VARIABLE: `retries`\n> Signature: `var retries = 0`\n> Lines: 401-401\n```\n401: var retries = 0\n```\n\n### VARIABLE: `attempts`\n> Signature: `var attempts = 0`\n> Lines: 402-402\n```\n402: var attempts = 0\n```\n\n### VARIABLE: `state`\n> Signature: `var state = \"idle\"`\n> Lines: 403-403\n```\n403: var state = \"idle\"\n```\n\n### FUNCTION: `reqCoverKotlin1`\n> Signature: `fun reqCoverKotlin1(value: Int): Int = value + 1`\n> Lines: 413-413\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\n413: fun reqCoverKotlin1(value: Int): Int = value + 1\n```\n\n### FUNCTION: `reqCoverKotlin2`\n> Signature: `fun reqCoverKotlin2(value: Int): Int = value + 2`\n> Lines: 422-422\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\n422: fun reqCoverKotlin2(value: Int): Int = value + 2\n```\n\n### FUNCTION: `reqCoverKotlin3`\n> Signature: `fun reqCoverKotlin3(value: Int): Int = value + 3`\n> Lines: 431-431\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\n431: fun reqCoverKotlin3(value: Int): Int = value + 3\n```\n\n### FUNCTION: `reqCoverKotlin4`\n> Signature: `fun reqCoverKotlin4(value: Int): Int = value + 4`\n> Lines: 440-440\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\n440: fun reqCoverKotlin4(value: Int): Int = value + 4\n```\n\n### FUNCTION: `reqCoverKotlin5`\n> Signature: `fun reqCoverKotlin5(value: Int): Int = value + 5`\n> Lines: 449-449\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\n449: fun reqCoverKotlin5(value: Int): Int = value + 5\n```\n\n@@@ <PROJECT_BASE>/src/fixture_lua.lua | lua\n\n### FUNCTION: `globalFunc`\n> Signature: `function globalFunc(x)`\n> Lines: 14-16\n- @param x number The input value.\n---\n- @return number The input incremented by one.\n```\n14: function globalFunc(x)\n15: return x + 1\n16: end\n```\n\n### FUNCTION: `localFunc`\n> Signature: `local function localFunc(y)`\n> Lines: 22-28\n```\n22: local function localFunc(y)\n23: if type(y) ~= \"number\" then\n24: error(\"expected number, got \" .. type(y))\n25: end\n27: return y * 2\n28: end\n```\n\n### FUNCTION: `sumAll`\n> Signature: `local function sumAll(...)`\n> Lines: 33-41\n- @param ... number Variable number of numeric arguments.\n---\n- @return number Sum of all provided values.\n```\n33: local function sumAll(...)\n34: local total = 0\n35: local args = {...}\n36: for _, v in ipairs(args) do\n38: total = total + v\n39: end\n40: return total\n41: end\n```\n\n### VARIABLE: `total`\n> Signature: `local total = 0`\n> Lines: 34-34\n```\n34: local total = 0\n```\n\n### VARIABLE: `args`\n> Signature: `local args = {...}`\n> Lines: 35-35\n```\n35: local args = {...}\n```\n\n### VARIABLE: `myVar`\n> Signature: `local myVar = 42`\n> Lines: 46-46\n- @brief Module-level constant for retry limits.\n```\n46: local myVar = 42\n```\n\n### VARIABLE: `config`\n> Signature: `local config =`\n> Lines: 49-49\n- @brief Configuration table with default settings.\n```\n49: local config = {\n```\n\n### FUNCTION: `handler`\n> Signature: `local handler = function(event)`\n> Lines: 59-66\n- @param event table Event object containing type and data fields.\n```\n59: local handler = function(event)\n61: if event.type == \"click\" then\n62: print(\"clicked at \" .. event.x .. \",\" .. event.y)\n63: else\n64: print(\"event: \" .. event.type)\n65: end\n66: end\n```\n\n### VARIABLE: `MyModule`\n> Signature: `local MyModule = {}`\n> Lines: 72-72\n- @brief Table-based module using method syntax.\n```\n72: local MyModule = {}\n```\n\n### FUNCTION: `MyModule.new`\n> Signature: `function MyModule.new(name)`\n> Lines: 78-83\n- @param name string Instance identifier.\n---\n- @return table New MyModule instance.\n```\n78: function MyModule.new(name)\n79: local self = setmetatable({}, MyModule)\n80: self.name = name\n81: self._items = {}\n82: return self\n83: end\n```\n\n### VARIABLE: `self`\n> Signature: `local self = setmetatable({}, MyModule)`\n> Lines: 79-79\n```\n79: local self = setmetatable({}, MyModule)\n```\n\n### FUNCTION: `MyModule.method`\n> Signature: `MyModule.method = function(self)`\n> Lines: 88-90\n- @param self table The MyModule instance.\n---\n- @return string The instance name.\n```\n88: MyModule.method = function(self)\n89: return self.name\n90: end\n```\n\n### FUNCTION: `MyModule:addItem`\n> Signature: `function MyModule:addItem(item)`\n> Lines: 94-97\n- @param item any The item to store.\n```\n94: function MyModule:addItem(item)\n96: table.insert(self._items, item)\n97: end\n```\n\n### FUNCTION: `MyModule:count`\n> Signature: `function MyModule:count()`\n> Lines: 101-103\n- @return number Number of items.\n```\n101: function MyModule:count()\n102: return #self._items\n103: end\n```\n\n### VARIABLE: `Animal`\n> Signature: `local Animal = {}`\n> Lines: 109-109\n- @brief Base class using metatables for inheritance.\n```\n109: local Animal = {}\n```\n\n### FUNCTION: `Animal.new`\n> Signature: `function Animal.new(species)`\n> Lines: 115-119\n- @param species string The animal's species.\n---\n- @return table New Animal instance.\n```\n115: function Animal.new(species)\n116: local self = setmetatable({}, Animal)\n117: self.species = species\n118: return self\n119: end\n```\n\n### VARIABLE: `self`\n> Signature: `local self = setmetatable({}, Animal)`\n> Lines: 116-116\n```\n116: local self = setmetatable({}, Animal)\n```\n\n### FUNCTION: `Animal:speak`\n> Signature: `function Animal:speak()`\n> Lines: 123-125\n- @return string Sound description.\n```\n123: function Animal:speak()\n124: return self.species .. \" says ...\"\n125: end\n```\n\n### VARIABLE: `Dog`\n> Signature: `local Dog = setmetatable({}, { __index = Animal })`\n> Lines: 129-129\n- @brief Dog subclass inheriting from Animal.\n```\n129: local Dog = setmetatable({}, { __index = Animal })\n```\n\n### FUNCTION: `Dog.new`\n> Signature: `function Dog.new(name)`\n> Lines: 135-140\n- @param name string The dog's name.\n---\n- @return table New Dog instance.\n```\n135: function Dog.new(name)\n136: local self = Animal.new(\"Dog\")\n137: setmetatable(self, Dog)\n138: self.dogName = name\n139: return self\n140: end\n```\n\n### VARIABLE: `self`\n> Signature: `local self = Animal.new(\"Dog\")`\n> Lines: 136-136\n```\n136: local self = Animal.new(\"Dog\")\n```\n\n### FUNCTION: `Dog:speak`\n> Signature: `function Dog:speak()`\n> Lines: 144-146\n- @return string The dog's vocalization.\n```\n144: function Dog:speak()\n145: return self.dogName .. \" says Woof!\"\n146: end\n```\n\n### FUNCTION: `makeCounter`\n> Signature: `local function makeCounter(step)`\n> Lines: 153-160\n- @param step number Increment amount per call.\n---\n- @return function Closure returning successive counts.\n```\n153: local function makeCounter(step)\n154: local count = 0\n155: return function()\n157: count = count + step\n158: return count\n159: end\n160: end\n```\n\n### VARIABLE: `count`\n> Signature: `local count = 0`\n> Lines: 154-154\n```\n154: local count = 0\n```\n\n### FUNCTION: `fibonacci`\n> Signature: `local function fibonacci(limit)`\n> Lines: 167-176\n- @param limit number Maximum number of values to yield.\n---\n- @return function Coroutine wrap function.\n```\n167: local function fibonacci(limit)\n168: return coroutine.wrap(function()\n169: local a, b = 0, 1\n170: for _ = 1, limit do\n171: coroutine.yield(a)\n173: a, b = b, a + b\n174: end\n175: end)\n176: end\n```\n\n### FUNCTION: `safeCall`\n> Signature: `local function safeCall(fn, ...)`\n> Lines: 184-192\n- @param fn function The function to execute.\n---\n- @param ... any Arguments to pass to fn.\n---\n- @return boolean, any Success flag and result or error message.\n```\n184: local function safeCall(fn, ...)\n185: local ok, result = pcall(fn, ...)\n186: if not ok then\n188: print(\"Error: \" .. tostring(result))\n189: return false, nil\n190: end\n191: return true, result\n192: end\n```\n\n### VARIABLE: `mixedTable`\n> Signature: `local mixedTable =`\n> Lines: 197-197\n- @brief Complex table demonstrating all key types.\n```\n197: local mixedTable = {\n```\n\n### FUNCTION: `range`\n> Signature: `local function range(from, to)`\n> Lines: 219-228\n- @param from number Start of range (inclusive).\n---\n- @param to number End of range (inclusive).\n---\n- @return function Iterator function.\n```\n219: local function range(from, to)\n220: local i = from - 1\n221: return function()\n222: i = i + 1\n223: if i <= to then\n224: return i\n225: end\n227: end\n228: end\n```\n\n### VARIABLE: `i`\n> Signature: `local i = from - 1`\n> Lines: 220-220\n```\n220: local i = from - 1\n```\n\n### FUNCTION: `req_cover_lua_1`\n> Signature: `function req_cover_lua_1(value)`\n> Lines: 236-238\n- @brief Coverage helper construct 1.\n--\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n--\n- @param value Input value for helper construct 1.\n--\n- @return Output value for helper construct 1.\n```\n236: function req_cover_lua_1(value)\n237: return value + 1\n238: end\n```\n\n### FUNCTION: `req_cover_lua_2`\n> Signature: `function req_cover_lua_2(value)`\n> Lines: 245-247\n- @brief Coverage helper construct 2.\n--\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n--\n- @param value Input value for helper construct 2.\n--\n- @return Output value for helper construct 2.\n```\n245: function req_cover_lua_2(value)\n246: return value + 2\n247: end\n```\n\n### FUNCTION: `req_cover_lua_3`\n> Signature: `function req_cover_lua_3(value)`\n> Lines: 254-256\n- @brief Coverage helper construct 3.\n--\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n--\n- @param value Input value for helper construct 3.\n--\n- @return Output value for helper construct 3.\n```\n254: function req_cover_lua_3(value)\n255: return value + 3\n256: end\n```\n\n### FUNCTION: `req_cover_lua_4`\n> Signature: `function req_cover_lua_4(value)`\n> Lines: 263-265\n- @brief Coverage helper construct 4.\n--\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n--\n- @param value Input value for helper construct 4.\n--\n- @return Output value for helper construct 4.\n```\n263: function req_cover_lua_4(value)\n264: return value + 4\n265: end\n```\n\n### FUNCTION: `req_cover_lua_5`\n> Signature: `function req_cover_lua_5(value)`\n> Lines: 272-274\n- @brief Coverage helper construct 5.\n--\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n--\n- @param value Input value for helper construct 5.\n--\n- @return Output value for helper construct 5.\n```\n272: function req_cover_lua_5(value)\n273: return value + 5\n274: end\n```\n\n@@@ <PROJECT_BASE>/src/fixture_perl.pl | perl\n\n### IMPORT: `strict`\n> Lines: 18-18\n```\n18: use strict;\n```\n\n### IMPORT: `warnings`\n> Lines: 19-19\n```\n19: use warnings;\n```\n\n### IMPORT: `Carp qw(croak confess)`\n> Lines: 20-20\n```\n20: use Carp qw(croak confess);\n```\n\n### IMPORT: `Exporter`\n> Lines: 21-21\n```\n21: require Exporter;\n```\n\n### FUNCTION: `new`\n> Signature: `sub new`\n> Lines: 48-48\n- @brief Create a new MyPackage instance.\n- @param class The class name (implicit first argument).\n- @param %args Named arguments: name (required), age (optional).\n- @return Blessed hashref instance.\n=cut\n```\n48: sub new {\n```\n\n### FUNCTION: `name`\n> Signature: `sub name`\n> Lines: 62-62\n- @brief Accessor for the name attribute.\n- @return The instance name string.\n```\n62: sub name {\n```\n\n### FUNCTION: `is_valid`\n> Signature: `sub is_valid`\n> Lines: 74-74\n- @brief Check if the instance is in a valid state.\n- @return 1 if valid, 0 otherwise.\n```\n74: sub is_valid {\n```\n\n### FUNCTION: `greet`\n> Signature: `sub greet`\n> Lines: 83-83\n- @brief Print a greeting to stdout.\n- @param $name The person's name.\n```\n83: sub greet {\n```\n\n### FUNCTION: `process`\n> Signature: `sub process`\n> Lines: 95-95\n- @brief Process data and return result.\n- @return 1 indicating success.\n```\n95: sub process {\n```\n\n### FUNCTION: `format_output`\n> Signature: `sub format_output`\n> Lines: 102-102\n- @brief Format output depending on context (list vs scalar).\n- @param @items List of items to format.\n- @return In list context: formatted items. In scalar: count.\n```\n102: sub format_output {\n```\n\n### FUNCTION: `helper`\n> Signature: `sub helper`\n> Lines: 115-115\n- @brief Standalone helper for internal use.\n- @return Always returns \"ok\".\n```\n115: sub helper {\n```\n\n### FUNCTION: `extract_emails`\n> Signature: `sub extract_emails`\n> Lines: 124-124\n- @brief Extract all email addresses from text.\n- @param $text Input text to scan.\n- @return List of matched email addresses.\n```\n124: sub extract_emails {\n```\n\n### FUNCTION: `replace_all`\n> Signature: `sub replace_all`\n> Lines: 139-139\n- @brief Replace all occurrences of a pattern in text.\n- @param $text Input text.\n- @param $pattern Regex pattern to find.\n- @param $replacement Replacement string.\n- @return Modified text with substitutions applied.\n```\n139: sub replace_all {\n```\n\n### FUNCTION: `make_multiplier`\n> Signature: `sub make_multiplier`\n> Lines: 150-150\n- @brief Create a multiplier closure.\n- @param $factor The multiplication factor.\n- @return Coderef that multiplies its argument by factor.\n```\n150: sub make_multiplier {\n```\n\n### FUNCTION: `dispatch`\n> Signature: `sub dispatch`\n> Lines: 178-178\n```\n178: sub dispatch {\n```\n\n### FUNCTION: `generate_template`\n> Signature: `sub generate_template`\n> Lines: 190-190\n- @brief Generate a template string using a here-document.\n- @param $name Name to insert into the template.\n- @return Formatted multi-line string.\n```\n190: sub generate_template {\n```\n\n### FUNCTION: `AUTOLOAD`\n> Signature: `sub AUTOLOAD`\n> Lines: 210-210\n- @brief Handle undefined method calls dynamically.\n- @details Methods named get_* return the corresponding attribute.\n- @param @args Arguments passed to the auto-loaded method.\n- @return The attribute value or undef.\n```\n210: sub AUTOLOAD {\n```\n\n### FUNCTION: `safe_execute`\n> Signature: `sub safe_execute`\n> Lines: 230-230\n- @brief Execute a block with error trapping.\n- @param $code Coderef to execute.\n- @return Result of execution or undef on error.\n```\n230: sub safe_execute {\n```\n\n### IMPORT: `lib 'lib'`\n> Lines: 257-257\n```\n257: use lib 'lib';\n```\n\n### FUNCTION: `req_cover_perl_1`\n> Signature: `sub req_cover_perl_1`\n> Lines: 265-265\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\n265: sub req_cover_perl_1 {\n```\n\n### FUNCTION: `req_cover_perl_2`\n> Signature: `sub req_cover_perl_2`\n> Lines: 275-275\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\n275: sub req_cover_perl_2 {\n```\n\n### FUNCTION: `req_cover_perl_3`\n> Signature: `sub req_cover_perl_3`\n> Lines: 285-285\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\n285: sub req_cover_perl_3 {\n```\n\n### FUNCTION: `req_cover_perl_4`\n> Signature: `sub req_cover_perl_4`\n> Lines: 295-295\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\n295: sub req_cover_perl_4 {\n```\n\n### FUNCTION: `req_cover_perl_5`\n> Signature: `sub req_cover_perl_5`\n> Lines: 305-305\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\n305: sub req_cover_perl_5 {\n```\n\n@@@ <PROJECT_BASE>/src/fixture_php.php | php\n- @brief Comprehensive PHP test fixture for parser validation.\n- @details Covers enums with methods, union/intersection types, readonly\nproperties, constructor promotion, arrow functions, match expressions,\nfirst-class callables, attributes, fibers, and named arguments.\n\n### IMPORT: `App\\Contracts\\Repository`\n> Lines: 14-14\n```\n14: use App\\Contracts\\Repository;\n```\n\n### IMPORT: `App\\Events\\{ModelCreated, ModelDeleted}`\n> Lines: 15-15\n```\n15: use App\\Events\\{ModelCreated, ModelDeleted};\n```\n\n### IMPORT: `Psr\\Log\\LoggerInterface`\n> Lines: 16-16\n```\n16: use Psr\\Log\\LoggerInterface;\n```\n\n### IMPORT: `'config.php'`\n> Lines: 17-17\n```\n17: require_once 'config.php';\n```\n\n### FUNCTION: `isActive`\n> Signature: `public function isActive(): bool`\n> Lines: 45-47\n- @brief Check if the status represents an active state.\n- @return bool True if the entity is publicly visible.\n```\n45: public function isActive(): bool {\n46: return $this === self::Published;\n47: }\n```\n\n### FUNCTION: `label`\n> Signature: `public function label(): string`\n> Lines: 53-59\n- @brief Get a human-readable label for display.\n- @return string Formatted status label.\n```\n53: public function label(): string {\n54: return match($this) {\n55: self::Draft => 'Draft',\n56: self::Published => 'Published',\n57: self::Archived => 'Archived',\n58: };\n59: }\n```\n\n### CLASS: `BaseModel`\n> Signature: `abstract class BaseModel`\n> Lines: 69-111\n- @brief Abstract base model with common persistence operations.\n- @brief Construct a model with promoted properties.\n- @details Uses constructor promotion for compact field declaration.\n- @param int $id Unique identifier (readonly after construction).\n- @param \\DateTimeImmutable $createdAt Timestamp of creation.\n```\n69: abstract class BaseModel {\n75: public function __construct(\n76: public readonly int $id,\n77: public readonly \\DateTimeImmutable $createdAt = new \\DateTimeImmutable(),\n78: ) {}\n84: public function save(): bool {\n86: if (!$this->validate()) {\n87: return false;\n88: }\n89: return true;\n90: }\n96: abstract protected function validate(): bool;\n102: private static function validateConstraints(): bool {\n103: return true;\n104: }\n110: abstract public function toArray(): array;\n111: }\n```\n\n### FUNCTION: `__construct`\n> Signature: `public function __construct(`\n> Lines: 75-78\n- @brief Construct a model with promoted properties.\n- @param int $id Unique identifier (readonly after construction).\n- @param \\DateTimeImmutable $createdAt Timestamp of creation.\n```\n75: public function __construct(\n76: public readonly int $id,\n77: public readonly \\DateTimeImmutable $createdAt = new \\DateTimeImmutable(),\n78: ) {}\n```\n\n### FUNCTION: `save`\n> Signature: `public function save(): bool`\n> Lines: 84-90\n- @brief Persist the model to the data store.\n- @return bool True if save succeeded.\n```\n84: public function save(): bool {\n86: if (!$this->validate()) {\n87: return false;\n88: }\n89: return true;\n90: }\n```\n\n### FUNCTION: `validateConstraints`\n> Signature: `private static function validateConstraints(): bool`\n> Lines: 102-104\n- @brief Internal validation helper with type narrowing.\n- @return bool True if entity passes all constraint checks.\n```\n102: private static function validateConstraints(): bool {\n103: return true;\n104: }\n```\n\n### CLASS: `User`\n> Signature: `final class User extends BaseModel`\n> Lines: 120-179\n- @brief Concrete user entity with union and intersection types.\n- @brief User's display name.\n```\n120: final class User extends BaseModel {\n122: private string $name;\n125: private ?string $email;\n133: public function __construct(\n134: int $id,\n135: string $name,\n136: ?string $email = null,\n137: ) {\n138: parent::__construct($id);\n139: $this->name = $name;\n140: $this->email = $email;\n141: }\n147: public function getName(): string {\n148: return $this->name;\n149: }\n155: public function getIdentifier(): string|int {\n157: return $this->email ?? $this->id;\n158: }\n164: protected function validate(): bool {\n165: return strlen($this->name) > 0;\n166: }\n172: public function toArray(): array {\n173: return [\n174: 'id' => $this->id,\n175: 'name' => $this->name,\n176: 'email' => $this->email,\n177: ];\n178: }\n179: }\n```\n\n### FUNCTION: `__construct`\n> Signature: `public function __construct(`\n> Lines: 133-141\n- @brief Construct a User with promoted and explicit properties.\n- @param int $id Unique user ID.\n- @param string $name Display name.\n- @param string|null $email Optional email address.\n```\n133: public function __construct(\n134: int $id,\n135: string $name,\n136: ?string $email = null,\n137: ) {\n138: parent::__construct($id);\n139: $this->name = $name;\n140: $this->email = $email;\n141: }\n```\n\n### FUNCTION: `getName`\n> Signature: `public function getName(): string`\n> Lines: 147-149\n- @brief Get the user's display name.\n- @return string The user name.\n```\n147: public function getName(): string {\n148: return $this->name;\n149: }\n```\n\n### FUNCTION: `getIdentifier`\n> Signature: `public function getIdentifier(): string|int`\n> Lines: 155-158\n- @brief Get a value that may be string or int.\n- @return string|int The identifier in either format.\n```\n155: public function getIdentifier(): string|int {\n157: return $this->email ?? $this->id;\n158: }\n```\n\n### FUNCTION: `validate`\n> Signature: `protected function validate(): bool`\n> Lines: 164-166\n- @brief Validate user-specific constraints.\n- @return bool True if name is non-empty.\n```\n164: protected function validate(): bool {\n165: return strlen($this->name) > 0;\n166: }\n```\n\n### FUNCTION: `toArray`\n> Signature: `public function toArray(): array`\n> Lines: 172-178\n- @brief Serialize user to array.\n- @return array<string, mixed> User data array.\n```\n172: public function toArray(): array {\n173: return [\n174: 'id' => $this->id,\n175: 'name' => $this->name,\n176: 'email' => $this->email,\n177: ];\n178: }\n```\n\n### FUNCTION: `findAll`\n> Signature: `public function findAll(): iterable`\n> Lines: 192-215\n- @brief Retrieve all entities.\n- @brief Find a single entity by ID.\n- @param int $id Entity identifier.\n- @return iterable<BaseModel> Collection of models.\n- @return BaseModel|null The found entity or null.\n```\n192: public function findAll(): iterable;\n199: public function findById(int $id): ?BaseModel;\n206: public function count(array $criteria = []): int;\n207: }\n215: trait Cacheable {\n```\n\n### FUNCTION: `findById`\n> Signature: `public function findById(int $id): ?BaseModel`\n> Lines: 199-215\n- @brief Find a single entity by ID.\n- @brief Count entities matching a filter.\n- @param int $id Entity identifier.\n- @param array<string, mixed> $criteria Filter criteria.\n- @return BaseModel|null The found entity or null.\n- @return int Number of matching entities.\n```\n199: public function findById(int $id): ?BaseModel;\n206: public function count(array $criteria = []): int;\n207: }\n215: trait Cacheable {\n```\n\n### FUNCTION: `count`\n> Signature: `public function count(array $criteria = []): int`\n> Lines: 206-215\n- @brief Count entities matching a filter.\n- @param array<string, mixed> $criteria Filter criteria.\n- @return int Number of matching entities.\n```\n206: public function count(array $criteria = []): int;\n207: }\n215: trait Cacheable {\n```\n\n### FUNCTION: `cache`\n> Signature: `public function cache(): bool`\n> Lines: 223-226\n- @brief Store the current object in cache.\n- @return bool True if caching succeeded.\n```\n223: public function cache(): bool {\n225: return true;\n226: }\n```\n\n### FUNCTION: `invalidateCache`\n> Signature: `public function invalidateCache(): void`\n> Lines: 232-234\n- @brief Invalidate the cached version of this object.\n- @return void\n```\n232: public function invalidateCache(): void {\n234: }\n```\n\n### FUNCTION: `softDelete`\n> Signature: `public function softDelete(): void`\n> Lines: 255-257\n- @brief Mark the entity as soft-deleted.\n- @return void\n```\n255: public function softDelete(): void {\n256: $this->deletedAt = new \\DateTimeImmutable();\n257: }\n```\n\n### FUNCTION: `isDeleted`\n> Signature: `public function isDeleted(): bool`\n> Lines: 263-265\n- @brief Check if the entity is currently deleted.\n- @return bool True if soft-deleted.\n```\n263: public function isDeleted(): bool {\n264: return $this->deletedAt !== null;\n265: }\n```\n\n### CLASS: `CachedUser`\n> Signature: `final class CachedUser extends User`\n> Lines: 275-286\n- @brief User entity with caching and soft-delete capabilities.\n```\n275: final class CachedUser extends User {\n276: use Cacheable;\n277: use SoftDeletable;\n283: public function cacheKey(): string {\n284: return \"user:{$this->id}\";\n285: }\n286: }\n```\n\n### IMPORT: `Cacheable`\n> Lines: 276-276\n```\n276: use Cacheable;\n```\n\n### IMPORT: `SoftDeletable`\n> Lines: 277-277\n```\n277: use SoftDeletable;\n```\n\n### FUNCTION: `cacheKey`\n> Signature: `public function cacheKey(): string`\n> Lines: 283-285\n- @brief Generate a unique cache key for this user.\n- @return string Cache key in format \"user:{id}\".\n```\n283: public function cacheKey(): string {\n284: return \"user:{$this->id}\";\n285: }\n```\n\n### CLASS: `Route`\n> Signature: `class Route`\n> Lines: 295-305\n- @brief PHP attribute for annotating controller methods with routes.\n- @brief Define a route attribute.\n- @param string $path URL path pattern.\n- @param string $method HTTP method (GET, POST, etc.).\n```\n295: class Route {\n301: public function __construct(\n302: public readonly string $path,\n303: public readonly string $method = 'GET',\n304: ) {}\n305: }\n```\n\n### FUNCTION: `__construct`\n> Signature: `public function __construct(`\n> Lines: 301-304\n- @brief Define a route attribute.\n- @param string $path URL path pattern.\n- @param string $method HTTP method (GET, POST, etc.).\n```\n301: public function __construct(\n302: public readonly string $path,\n303: public readonly string $method = 'GET',\n304: ) {}\n```\n\n### FUNCTION: `helper`\n> Signature: `function helper(): bool`\n> Lines: 314-316\n- @brief Standalone helper returning a boolean result.\n- @return bool Always returns true.\n```\n314: function helper(): bool {\n315: return true;\n316: }\n```\n\n### FUNCTION: `processData`\n> Signature: `function processData(mixed $data): string`\n> Lines: 324-333\n- @brief Process data using match expression for type dispatching.\n- @param mixed $data Input data of any type.\n- @return string Description of the processed data.\n```\n324: function processData(mixed $data): string {\n326: return match(true) {\n327: is_string($data) => \"string: \" . strlen($data),\n328: is_int($data) => \"int: $data\",\n329: is_array($data) => \"array: \" . count($data),\n330: $data instanceof BaseModel => \"model: \" . $data->id,\n331: default => \"unknown\",\n332: };\n333: }\n```\n\n### FUNCTION: `applyTransform`\n> Signature: `function applyTransform(array $items, callable $fn): array`\n> Lines: 342-344\n- @brief Higher-order function using arrow function syntax.\n- @param array<int> $items Array of integers.\n- @param callable(int): int $fn Transform function.\n- @return array<int> Transformed array.\n```\n342: function applyTransform(array $items, callable $fn): array {\n343: return array_map(fn(int $x): int => $fn($x), $items);\n344: }\n```\n\n### FUNCTION: `createMultiplier`\n> Signature: `function createMultiplier(int $factor): \\Closure`\n> Lines: 352-355\n- @brief Create a closure that multiplies its argument.\n- @param int $factor The multiplication factor.\n- @return \\Closure(int): int A multiplier closure.\n```\n352: function createMultiplier(int $factor): \\Closure {\n354: return fn(int $x): int => $x * $factor;\n355: }\n```\n\n### FUNCTION: `readFileContent`\n> Signature: `function readFileContent(string $path): string|false`\n> Lines: 363-368\n- @brief Read file contents with comprehensive error handling.\n- @param string $path File system path.\n- @return string|false File contents or false on failure.\n```\n363: function readFileContent(string $path): string|false {\n364: if (!file_exists($path)) {\n365: return false;\n366: }\n367: return file_get_contents($path);\n368: }\n```\n\n### CLASS: `ApiClient`\n> Signature: `final class ApiClient {}`\n> Lines: 385-385\n```\n385: final class ApiClient {}\n```\n\n### FUNCTION: `req_cover_php_1`\n> Signature: `function req_cover_php_1(int $value): int { return $value + 1; }`\n> Lines: 395-395\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\n395: function req_cover_php_1(int $value): int { return $value + 1; }\n```\n\n### FUNCTION: `req_cover_php_2`\n> Signature: `function req_cover_php_2(int $value): int { return $value + 2; }`\n> Lines: 404-404\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\n404: function req_cover_php_2(int $value): int { return $value + 2; }\n```\n\n### FUNCTION: `req_cover_php_3`\n> Signature: `function req_cover_php_3(int $value): int { return $value + 3; }`\n> Lines: 413-413\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\n413: function req_cover_php_3(int $value): int { return $value + 3; }\n```\n\n### FUNCTION: `req_cover_php_4`\n> Signature: `function req_cover_php_4(int $value): int { return $value + 4; }`\n> Lines: 422-422\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\n422: function req_cover_php_4(int $value): int { return $value + 4; }\n```\n\n### FUNCTION: `req_cover_php_5`\n> Signature: `function req_cover_php_5(int $value): int { return $value + 5; }`\n> Lines: 431-431\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\n431: function req_cover_php_5(int $value): int { return $value + 5; }\n```\n\n@@@ <PROJECT_BASE>/src/fixture_python.py | python\n- @brief Comprehensive Python test fixture for parser validation.\n- @details Covers classes, protocols, decorators, generators, async functions, and rich Doxygen-tagged constructs used to validate extraction workflows and deterministic parser behavior.\n\n### IMPORT: `asyncio  #!< @brief Async IO support. @details Used for async test fixtures. # noqa: F401`\n> Lines: 7-7\n- @brief Async IO support.\n- @details Used for async test fixtures. # noqa: F401\n```\n7: import asyncio\n```\n\n### IMPORT: `os  #!< @brief OS interface module. @details Provides OS-dependent functionality. # noqa: F401`\n> Lines: 8-8\n- @brief OS interface module.\n- @details Provides OS-dependent functionality. # noqa: F401\n```\n8: import os\n```\n\n### IMPORT: `sys  #!< @brief System-specific parameters. @see sys.exit() for exit handling.`\n> Lines: 9-9\n- @brief System-specific parameters.\n- @see sys.exit() for exit handling.\n```\n9: import sys\n```\n\n### IMPORT: `Path  #!< @brief Object-oriented filesystem paths. @note Preferred over os.path. # noqa: F401`\n> Lines: 10-10\n- @brief Object-oriented filesystem paths.\n- @note Preferred over os.path. # noqa: F401\n```\n10: from pathlib import Path\n```\n\n### IMPORT: `(`\n> Lines: 11-11\n```\n11: from typing import (\n```\n\n### IMPORT: `dataclass, field`\n> Lines: 15-15\n```\n15: from dataclasses import dataclass, field\n```\n\n### IMPORT: `ABC, abstractmethod`\n> Lines: 16-16\n```\n16: from abc import ABC, abstractmethod\n```\n\n### IMPORT: `contextmanager`\n> Lines: 17-17\n```\n17: from contextlib import contextmanager\n```\n\n### VARIABLE: `MAX_RETRIES`\n> Signature: `MAX_RETRIES = 3  #!< @brief Maximum retry attempts. @details Applied to network operations. @warning Tune per use case. @satisfies retry-policy`\n> Lines: 19-19\n- @brief Maximum retry attempts.\n- @details Applied to network operations.\n- @warning Tune per use case.\n- @satisfies retry-policy\n```\n19: MAX_RETRIES = 3\n```\n\n### VARIABLE: `DEFAULT_TIMEOUT`\n> Signature: `DEFAULT_TIMEOUT = 30.0  #!< @brief Default timeout in seconds. @note For I/O operations.`\n> Lines: 20-20\n- @brief Default timeout in seconds.\n- @note For I/O operations.\n```\n20: DEFAULT_TIMEOUT = 30.0\n```\n\n### DECORATOR: `dataclass`\n> Lines: 26-26\n```\n26: @dataclass(slots=True)\n```\n\n### CLASS: `Config`\n> Signature: `class Config`\n> Lines: 27-61\n- @brief Stores key-value pairs with optional default fallback.\n- @details Dataclass-based configuration with validation.\n- @note Immutable after creation when frozen=True is used.\n- @see __post_init__() for validation logic.\n```\n27: class Config:\n35:     name: str\n36:     values: Dict[str, str] = field(default_factory=dict)\n37:     debug: bool = False\n39:     def get(self, key: str, default: str = \"\") -> str:\n47:         if key in self.values:\n48:             return self.values[key]\n50:         return default\n52:     def __post_init__(self) -> None:\n58:         if not self.name.strip():\n59:             raise ValueError(\"Config name cannot be empty\")\n```\n\n### FUNCTION: `get`\n> Signature: `def get(self, key: str, default: str = \"\") -> str`\n> Lines: 39-51\n- @brief Stores key-value pairs with optional default fallback.\n- @details Dataclass-based configuration with validation.\n- @param key The configuration key to look up.\n- @param default Fallback value if key is missing.\n- @return The configuration value or default.\n- @note Immutable after creation when frozen=True is used.\n- @see __post_init__() for validation logic.\n```\n39:     def get(self, key: str, default: str = \"\") -> str:\n47:         if key in self.values:\n48:             return self.values[key]\n50:         return default\n```\n\n### FUNCTION: `__post_init__`\n> Signature: `def __post_init__(self) -> None`\n> Lines: 52-61\n- @brief Ensures name is non-empty and normalizes values. @raises ValueError If name is empty or whitespace.\n```\n52:     def __post_init__(self) -> None:\n58:         if not self.name.strip():\n59:             raise ValueError(\"Config name cannot be empty\")\n```\n\n### CLASS: `MyClass`\n> Signature: `class MyClass`\n> Lines: 62-167\n- @brief Base class demonstrating various Python constructs.\n- @details Includes nested classes, properties, and static methods.\n```\n62: class MyClass:\n69:     class InnerHelper:\n74:         def __init__(self, tag: str):\n79:             self.tag = tag\n81:         def describe(self) -> str:\n86:             return f\"Helper({self.tag})\"\n88:     def __init__(self, name: str, retries: int = MAX_RETRIES):\n94:         self._name = name\n95:         self._retries = retries\n97:         self._call_count = 0\n99:     @property\n100:     def name(self) -> str:\n105:         return self._name\n107:     @name.setter\n108:     def name(self, value: str) -> None:\n114:         if not value:\n115:             raise ValueError(\"Name cannot be empty\")\n116:         self._name = value\n118:     @staticmethod\n119:     def create_default() -> \"MyClass\":\n124:         return MyClass(\"default\")\n126:     @classmethod\n127:     def from_dict(cls, data: dict) -> \"MyClass\":\n134:         return cls(\n135:             name=data[\"name\"],\n136:             retries=data.get(\"retries\", MAX_RETRIES),\n137:         )\n139:     def process(self, items: List[str], *, verbose: bool = False) -> Optional[str]:\n146:         self._call_count += 1\n147:         for item in items:\n149:             if not item.strip():\n150:                 continue\n151:             if verbose:\n152:                 print(f\"Processing: {item}\")\n154:             return item if len(item) > 1 else item.upper()\n155:         return None\n157:     def compute(self, x: int, y: int) -> int:\n165:         return (x + y) if (x > 0 and y > 0) else abs(x - y)\n```\n\n### CLASS: `InnerHelper`\n> Signature: `class InnerHelper`\n> Lines: 69-87\n- @brief Base class demonstrating various Python constructs.\n- @brief Handles auxiliary computations within MyClass scope.\n- @details Includes nested classes, properties, and static methods.\n```\n69:     class InnerHelper:\n74:         def __init__(self, tag: str):\n79:             self.tag = tag\n81:         def describe(self) -> str:\n86:             return f\"Helper({self.tag})\"\n```\n\n### FUNCTION: `__init__`\n> Signature: `def __init__(self, tag: str)`\n> Lines: 74-80\n- @brief Handles auxiliary computations within MyClass scope.\n- @param tag Short label for categorization.\n```\n74:         def __init__(self, tag: str):\n79:             self.tag = tag\n```\n\n### FUNCTION: `describe`\n> Signature: `def describe(self) -> str`\n> Lines: 81-87\n- @return String combining class name and tag.\n```\n81:         def describe(self) -> str:\n86:             return f\"Helper({self.tag})\"\n```\n\n### FUNCTION: `__init__`\n> Signature: `def __init__(self, name: str, retries: int = MAX_RETRIES)`\n> Lines: 88-98\n- @param name Identifier for this instance.\n- @param retries Maximum retry attempts; defaults to MAX_RETRIES.\n```\n88:     def __init__(self, name: str, retries: int = MAX_RETRIES):\n94:         self._name = name\n95:         self._retries = retries\n97:         self._call_count = 0\n```\n\n### DECORATOR: `property`\n> Lines: 99-99\n```\n99:     @property\n```\n\n### FUNCTION: `name`\n> Signature: `def name(self) -> str`\n> Lines: 100-106\n- @return The name string set during initialization.\n```\n100:     def name(self) -> str:\n105:         return self._name\n```\n\n### DECORATOR: `name.setter`\n> Lines: 107-107\n```\n107:     @name.setter\n```\n\n### FUNCTION: `name`\n> Signature: `def name(self, value: str) -> None`\n> Lines: 108-117\n- @param value New name; must be non-empty. @raises ValueError If value is empty.\n```\n108:     def name(self, value: str) -> None:\n114:         if not value:\n115:             raise ValueError(\"Name cannot be empty\")\n116:         self._name = value\n```\n\n### DECORATOR: `staticmethod`\n> Lines: 118-118\n```\n118:     @staticmethod\n```\n\n### FUNCTION: `create_default`\n> Signature: `def create_default() -> \"MyClass\"`\n> Lines: 119-125\n- @return A new MyClass instance with name='default'.\n```\n119:     def create_default() -> \"MyClass\":\n124:         return MyClass(\"default\")\n```\n\n### DECORATOR: `classmethod`\n> Lines: 126-126\n```\n126:     @classmethod\n```\n\n### FUNCTION: `from_dict`\n> Signature: `def from_dict(cls, data: dict) -> \"MyClass\"`\n> Lines: 127-138\n- @param data Dictionary with 'name' and optional 'retries' keys.\n- @return A new instance populated from data. @raises KeyError If 'name' key is missing.\n```\n127:     def from_dict(cls, data: dict) -> \"MyClass\":\n134:         return cls(\n135:             name=data[\"name\"],\n136:             retries=data.get(\"retries\", MAX_RETRIES),\n137:         )\n```\n\n### FUNCTION: `process`\n> Signature: `def process(self, items: List[str], *, verbose: bool = False) -> Optional[str]`\n> Lines: 139-156\n- @param items List of strings to process sequentially.\n- @param verbose Enable detailed logging when True.\n- @return The first valid item found or None if all are empty.\n```\n139:     def process(self, items: List[str], *, verbose: bool = False) -> Optional[str]:\n146:         self._call_count += 1\n147:         for item in items:\n149:             if not item.strip():\n150:                 continue\n151:             if verbose:\n152:                 print(f\"Processing: {item}\")\n154:             return item if len(item) > 1 else item.upper()\n155:         return None\n```\n\n### FUNCTION: `compute`\n> Signature: `def compute(self, x: int, y: int) -> int`\n> Lines: 157-167\n- @param x First operand.\n- @param y Second operand.\n- @return Sum if both positive, difference otherwise.\n```\n157:     def compute(self, x: int, y: int) -> int:\n165:         return (x + y) if (x > 0 and y > 0) else abs(x - y)\n```\n\n### CLASS: `AbstractProcessor`\n> Signature: `class AbstractProcessor(ABC)`\n> Lines: 168-196\n- @brief Defines the interface that concrete processors must implement.\n- @details ABC-based interface with abstract methods.\n- @note Subclasses must implement execute() and execute_async().\n- @see ConcreteProcessor for a working implementation.\n- @sa ABC documentation for abstract base class patterns.\n```\n168: class AbstractProcessor(ABC):\n178:     @abstractmethod\n179:     def execute(self, data: bytes) -> bool:\n185:         ...\n187:     @abstractmethod\n188:     async def execute_async(self, data: bytes) -> bool:\n194:         ...\n```\n\n### DECORATOR: `abstractmethod`\n> Lines: 178-178\n- @brief Defines the interface that concrete processors must implement.\n- @details ABC-based interface with abstract methods.\n- @note Subclasses must implement execute() and execute_async().\n- @see ConcreteProcessor for a working implementation.\n- @sa ABC documentation for abstract base class patterns.\n```\n178:     @abstractmethod\n```\n\n### FUNCTION: `execute`\n> Signature: `def execute(self, data: bytes) -> bool`\n> Lines: 179-186\n- @param data The raw input bytes to process.\n- @return True if processing succeeded, False otherwise.\n```\n179:     def execute(self, data: bytes) -> bool:\n185:         ...\n```\n\n### DECORATOR: `abstractmethod`\n> Lines: 187-187\n```\n187:     @abstractmethod\n```\n\n### FUNCTION: `execute_async`\n> Signature: `async def execute_async(self, data: bytes) -> bool`\n> Lines: 188-196\n- @param data The raw input bytes to process.\n- @return True if processing succeeded.\n```\n188:     async def execute_async(self, data: bytes) -> bool:\n194:         ...\n```\n\n### CLASS: `ConcreteProcessor`\n> Signature: `class ConcreteProcessor(AbstractProcessor)`\n> Lines: 197-231\n- @brief Processes byte data by decoding and validating content.\n- @details Implements synchronous and async execute methods.\n- @note Thread-safe for read operations.\n- @see AbstractProcessor for interface definition.\n```\n197: class ConcreteProcessor(AbstractProcessor):\n206:     def execute(self, data: bytes) -> bool:\n213:         try:\n214:             text = data.decode(\"utf-8\")\n216:             return bool(text.strip())\n217:         except UnicodeDecodeError:\n218:             return False\n219:         finally:\n221:             pass\n223:     async def execute_async(self, data: bytes) -> bool:\n229:         return self.execute(data)\n```\n\n### FUNCTION: `execute`\n> Signature: `def execute(self, data: bytes) -> bool`\n> Lines: 206-222\n- @brief Processes byte data by decoding and validating content.\n- @details Implements synchronous and async execute methods.\n- @param data Raw bytes, expected UTF-8 encoded text.\n- @return True if decoding and validation succeed. @raises UnicodeDecodeError Propagated if data is not valid UTF-8.\n- @note Thread-safe for read operations.\n- @see AbstractProcessor for interface definition.\n```\n206:     def execute(self, data: bytes) -> bool:\n213:         try:\n214:             text = data.decode(\"utf-8\")\n216:             return bool(text.strip())\n217:         except UnicodeDecodeError:\n218:             return False\n219:         finally:\n221:             pass\n```\n\n### FUNCTION: `execute_async`\n> Signature: `async def execute_async(self, data: bytes) -> bool`\n> Lines: 223-231\n- @param data Raw bytes to process asynchronously.\n- @return True if valid content found.\n```\n223:     async def execute_async(self, data: bytes) -> bool:\n229:         return self.execute(data)\n```\n\n### CLASS: `GenericContainer`\n> Signature: `class GenericContainer(Generic[T])`\n> Lines: 232-271\n- @brief Type-safe collection with iteration and lookup support.\n- @details Generic collection with find and iteration. @tparam T The element type stored in this container.\n- @note Implements __iter__ for iteration protocol.\n- @see typing.Generic for generics documentation.\n```\n232: class GenericContainer(Generic[T]):\n242:     def __init__(self) -> None:\n244:         self._items: List[T] = []\n246:     def add(self, item: T) -> None:\n251:         self._items.append(item)\n253:     def __iter__(self) -> Iterator[T]:\n258:         yield from self._items\n260:     def find(self, predicate) -> Optional[T]:\n266:         for item in self._items:\n267:             if predicate(item):\n268:                 return item\n269:         return None\n```\n\n### FUNCTION: `__init__`\n> Signature: `def __init__(self) -> None`\n> Lines: 242-245\n- @brief Type-safe collection with iteration and lookup support.\n- @details Generic collection with find and iteration.\n@tparam T The element type stored in this container.\n- @note Implements __iter__ for iteration protocol.\n- @see typing.Generic for generics documentation.\n```\n242:     def __init__(self) -> None:\n244:         self._items: List[T] = []\n```\n\n### FUNCTION: `add`\n> Signature: `def add(self, item: T) -> None`\n> Lines: 246-252\n- @param item Element of type T to add.\n```\n246:     def add(self, item: T) -> None:\n251:         self._items.append(item)\n```\n\n### FUNCTION: `__iter__`\n> Signature: `def __iter__(self) -> Iterator[T]`\n> Lines: 253-259\n- @return Iterator yielding items of type T.\n```\n253:     def __iter__(self) -> Iterator[T]:\n258:         yield from self._items\n```\n\n### FUNCTION: `find`\n> Signature: `def find(self, predicate) -> Optional[T]`\n> Lines: 260-271\n- @param predicate Callable accepting T and returning bool.\n- @return The first matching item or None.\n```\n260:     def find(self, predicate) -> Optional[T]:\n266:         for item in self._items:\n267:             if predicate(item):\n268:                 return item\n269:         return None\n```\n\n### CLASS: `Renderable`\n> Signature: `class Renderable(Protocol)`\n> Lines: 272-285\n- @brief Structural typing interface for render-capable objects.\n```\n272: class Renderable(Protocol):\n278:     def render(self) -> str:\n283:         ...\n```\n\n### FUNCTION: `render`\n> Signature: `def render(self) -> str`\n> Lines: 278-285\n- @brief Structural typing interface for render-capable objects.\n- @return Rendered string output.\n```\n278:     def render(self) -> str:\n283:         ...\n```\n\n### DECORATOR: `property`\n> Lines: 286-286\n```\n286: @property\n```\n\n### FUNCTION: `regular_function`\n> Signature: `def regular_function(x: int) -> int`\n> Lines: 287-295\n- @param x Input integer value.\n- @return The input value unchanged.\n```\n287: def regular_function(x: int) -> int:\n293:     return x\n```\n\n### FUNCTION: `function_with_walrus`\n> Signature: `def function_with_walrus(data: List[int]) -> Optional[int]`\n> Lines: 296-307\n- @param data List of integers to scan.\n- @return The first value greater than 10, or None.\n```\n296: def function_with_walrus(data: List[int]) -> Optional[int]:\n303:     if (n := next((x for x in data if x > 10), None)) is not None:\n304:         return n\n305:     return None\n```\n\n### FUNCTION: `multi_return_paths`\n> Signature: `def multi_return_paths(value: int) -> Union[str, int, None]`\n> Lines: 308-325\n- @param value Integer selector for branching logic.\n- @return A string, integer, or None depending on value.\n```\n308: def multi_return_paths(value: int) -> Union[str, int, None]:\n314:     match value:\n315:         case 0:\n316:             return \"zero\"\n317:         case n if n < 0:\n319:             return abs(n)\n320:         case n if n > 100:\n321:             return None\n322:         case _:\n323:             return str(value)\n```\n\n### FUNCTION: `generator_function`\n> Signature: `def generator_function(limit: int) -> Iterator[int]`\n> Lines: 326-336\n- @param limit Upper bound (exclusive) for generation. @yield Squared integers from 0 to limit-1.\n```\n326: def generator_function(limit: int) -> Iterator[int]:\n332:     for i in range(limit):\n334:         yield i * i\n```\n\n### FUNCTION: `async_generator`\n> Signature: `async def async_generator(items: List[str]) -> AsyncIterator[str]`\n> Lines: 337-347\n- @param items Source strings to process. @yield Upper-cased non-empty strings.\n```\n337: async def async_generator(items: List[str]) -> AsyncIterator[str]:\n343:     for item in items:\n344:         if item.strip():\n345:             yield item.upper()\n```\n\n### DECORATOR: `contextmanager`\n> Lines: 348-348\n- @brief Context manager decorator.\n- @see contextlib.contextmanager\n```\n348: @contextmanager\n```\n\n### FUNCTION: `managed_resource`\n> Signature: `def managed_resource(path: str)`\n> Lines: 349-362\n- @param path File system path to the resource. @yield The opened file handle. @raises IOError If the resource cannot be opened.\n```\n349: def managed_resource(path: str):\n356:     f = open(path, \"r\")\n357:     try:\n358:         yield f\n359:     finally:\n360:         f.close()\n```\n\n### FUNCTION: `closure_factory`\n> Signature: `def closure_factory(multiplier: int)`\n> Lines: 363-379\n- @param multiplier The fixed multiplier for the returned function.\n- @return A callable that multiplies input by multiplier.\n```\n363: def closure_factory(multiplier: int):\n369:     def inner(x: int) -> int:\n376:         return x * multiplier\n377:     return inner\n```\n\n### FUNCTION: `inner`\n> Signature: `def inner(x: int) -> int`\n> Lines: 369-376\n- @param multiplier The fixed multiplier for the returned function.\n- @param x Value to multiply.\n- @return A callable that multiplies input by multiplier.\n- @return Product of x and the captured multiplier.\n```\n369:     def inner(x: int) -> int:\n376:         return x * multiplier\n```\n\n### FUNCTION: `uses_unpacking`\n> Signature: `def uses_unpacking(*args: int, **kwargs: str) -> Dict[str, Union[int, str]]`\n> Lines: 380-393\n- @param args Positional integer arguments.\n- @param kwargs Named string arguments.\n- @return Combined dictionary of all arguments.\n```\n380: def uses_unpacking(*args: int, **kwargs: str) -> Dict[str, Union[int, str]]:\n387:     result: Dict[str, Union[int, str]] = {}\n388:     for i, val in enumerate(args):\n389:         result[f\"arg_{i}\"] = val\n390:     result.update(kwargs)\n391:     return result\n```\n\n### VARIABLE: `EVEN_SQUARES`\n> Signature: `EVEN_SQUARES = [x ** 2 for x in range(20) if x % 2 == 0]`\n> Lines: 398-398\n```\n398: EVEN_SQUARES = [x ** 2 for x in range(20) if x % 2 == 0]\n```\n\n### FUNCTION: `async_function`\n> Signature: `async def async_function()`\n> Lines: 401-408\n- @brief Minimal async function for testing async detection.\n```\n401: async def async_function():\n406:     await asyncio.sleep(0)\n```\n\n### FUNCTION: `deeply_nested_logic`\n> Signature: `def deeply_nested_logic(matrix: List[List[int]]) -> int`\n> Lines: 409-429\n- @param matrix 2D list of integers.\n- @return Cumulative sum of positive even values.\n```\n409: def deeply_nested_logic(matrix: List[List[int]]) -> int:\n415:     total = 0\n416:     for row in matrix:\n417:         for val in row:\n418:             if val > 0:\n419:                 if val % 2 == 0:\n421:                     total += val\n422:                 else:\n423:                     continue\n424:             else:\n426:                 pass\n427:     return total\n```\n\n### FUNCTION: `exception_handling_example`\n> Signature: `def exception_handling_example(path: str) -> Optional[str]`\n> Lines: 430-453\n- @param path File path to attempt reading.\n- @return File contents or None on failure.\n```\n430: def exception_handling_example(path: str) -> Optional[str]:\n436:     try:\n437:         with open(path, \"r\") as f:\n438:             content = f.read()\n439:         if not content:\n440:             raise ValueError(\"Empty file\")\n441:         return content\n442:     except FileNotFoundError:\n444:         return None\n445:     except (PermissionError, OSError) as e:\n447:         sys.exit(1)\n448:     except Exception:\n449:         raise\n450:     finally:\n452:         pass\n```\n\n### VARIABLE: `MAX_BATCH`\n> Signature: `MAX_BATCH = 64  # inline extension comment`\n> Lines: 455-455\n```\n455: MAX_BATCH = 64\n```\n\n### VARIABLE: `CACHE_LIMIT`\n> Signature: `CACHE_LIMIT = 128`\n> Lines: 457-457\n```\n457: CACHE_LIMIT = 128\n```\n\n### VARIABLE: `MAX_USERS`\n> Signature: `MAX_USERS = 500`\n> Lines: 459-459\n```\n459: MAX_USERS = 500\n```\n\n### FUNCTION: `req_cover_py_1`\n> Signature: `def req_cover_py_1(value: int) -> int`\n> Lines: 467-469\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\n467: def req_cover_py_1(value: int) -> int:\n468:     return value + 1\n```\n\n### FUNCTION: `req_cover_py_2`\n> Signature: `def req_cover_py_2(value: int) -> int`\n> Lines: 475-477\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\n475: def req_cover_py_2(value: int) -> int:\n476:     return value + 2\n```\n\n### FUNCTION: `req_cover_py_3`\n> Signature: `def req_cover_py_3(value: int) -> int`\n> Lines: 483-485\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\n483: def req_cover_py_3(value: int) -> int:\n484:     return value + 3\n```\n\n### FUNCTION: `req_cover_py_4`\n> Signature: `def req_cover_py_4(value: int) -> int`\n> Lines: 491-493\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\n491: def req_cover_py_4(value: int) -> int:\n492:     return value + 4\n```\n\n### FUNCTION: `req_cover_py_5`\n> Signature: `def req_cover_py_5(value: int) -> int`\n> Lines: 499-501\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\n499: def req_cover_py_5(value: int) -> int:\n500:     return value + 5\n```\n\n@@@ <PROJECT_BASE>/src/fixture_ruby.rb | ruby\n\n### IMPORT: `'json'`\n> Lines: 10-10\n```\n10: require 'json'\n```\n\n### IMPORT: `'set'`\n> Lines: 11-11\n```\n11: require 'set'\n```\n\n### IMPORT: `'helper'`\n> Lines: 12-12\n```\n12: require_relative 'helper'\n```\n\n### DECORATOR: `:name, :age`\n> Lines: 20-20\n```\n20: attr_accessor :name, :age\n```\n\n### FUNCTION: `log`\n> Signature: `def log(message)`\n> Lines: 29-31\n- @brief Log a message to stdout with the class name prefix.\n- @param message [String] The message to log.\n```\n29: def log(message)\n30: puts \"[#{self.class.name}] #{message}\"\n31: end\n```\n\n### FUNCTION: `log_error`\n> Signature: `def log_error(error)`\n> Lines: 35-38\n- @brief Log an error with backtrace information.\n- @param error [Exception] The exception to log.\n```\n35: def log_error(error)\n36: puts \"[ERROR] #{error.message}\"\n37: puts error.backtrace.first(5).join(\"\\n\") if error.backtrace\n38: end\n```\n\n### CLASS: `MyClass`\n> Signature: `class MyClass`\n> Lines: 47-153\n```\n47: class MyClass\n48: include Loggable\n49: include Comparable\n52: attr_accessor :name\n55: attr_reader :created_at\n60: def initialize(name, **options)\n61: @name = name\n62: @options = options\n63: @created_at = Time.now\n65: @options[:retries] ||= MAX_RETRIES\n66: end\n71: def self.create(attrs)\n72: new(attrs[:name], **attrs.except(:name))\n73: end\n78: def self.bulk_create(names)\n79: names.map { |n| new(n) }\n80: end\n84: def valid?\n85: !@name.nil? && !@name.empty?\n86: end\n91: def matches?(pattern)\n92: return false if @name.nil?\n93: pattern.match?(@name)\n94: end\n99: def <=>(other)\n100: @name <=> other.name\n101: end\n106: def +(other)\n107: self.class.new(\"#{@name}+#{other.name}\")\n108: end\n112: def to_s\n113: \"MyClass(#{@name})\"\n114: end\n121: def method_missing(method, *args, &block)\n122: if method.to_s.start_with?('find_by_')\n123: field = method.to_s.sub('find_by_', '')\n124: \"Finding by #{field}: #{args.first}\"\n125: else\n126: super\n127: end\n128: end\n134: def respond_to_missing?(method, include_private = false)\n135: method.to_s.start_with?('find_by_') || super\n136: end\n138: protected\n142: def internal_config\n143: @options.dup\n144: end\n146: private\n150: def validate!\n151: raise \"Invalid name\" unless valid?\n152: end\n153: end\n```\n\n### DECORATOR: `:name`\n> Lines: 52-52\n- @brief Read/write accessor for the instance name.\n```\n52: attr_accessor :name\n```\n\n### DECORATOR: `:created_at`\n> Lines: 55-55\n- @brief Read-only accessor for the creation timestamp.\n```\n55: attr_reader :created_at\n```\n\n### FUNCTION: `initialize`\n> Signature: `def initialize(name, **options)`\n> Lines: 60-66\n- @brief Initialize a new MyClass instance.\n- @param name [String] The instance identifier.\n- @param options [Hash] Optional configuration hash.\n```\n60: def initialize(name, **options)\n61: @name = name\n62: @options = options\n63: @created_at = Time.now\n65: @options[:retries] ||= MAX_RETRIES\n66: end\n```\n\n### FUNCTION: `create`\n> Signature: `def self.create(attrs)`\n> Lines: 71-73\n- @brief Factory method creating an instance from a hash.\n- @param attrs [Hash] Attribute hash with :name key required.\n- @return [MyClass] A new instance populated from attrs.\n```\n71: def self.create(attrs)\n72: new(attrs[:name], **attrs.except(:name))\n73: end\n```\n\n### FUNCTION: `bulk_create`\n> Signature: `def self.bulk_create(names)`\n> Lines: 78-80\n- @brief Build multiple instances from an array of names.\n- @param names [Array<String>] Names to create instances for.\n- @return [Array<MyClass>] Array of new instances.\n```\n78: def self.bulk_create(names)\n79: names.map { |n| new(n) }\n80: end\n```\n\n### FUNCTION: `valid?`\n> Signature: `def valid?`\n> Lines: 84-86\n- @brief Predicate checking if the instance is valid.\n- @return [Boolean] True if name is non-empty.\n```\n84: def valid?\n85: !@name.nil? && !@name.empty?\n86: end\n```\n\n### FUNCTION: `matches?`\n> Signature: `def matches?(pattern)`\n> Lines: 91-94\n- @brief Check if name matches a pattern.\n- @param pattern [Regexp] Regular expression to test against.\n- @return [Boolean] True if name matches the pattern.\n```\n91: def matches?(pattern)\n92: return false if @name.nil?\n93: pattern.match?(@name)\n94: end\n```\n\n### FUNCTION: `to_s`\n> Signature: `def to_s`\n> Lines: 112-114\n- @brief Convert to string representation.\n- @return [String] Human-readable description.\n```\n112: def to_s\n113: \"MyClass(#{@name})\"\n114: end\n```\n\n### FUNCTION: `method_missing`\n> Signature: `def method_missing(method, *args, &block)`\n> Lines: 121-128\n```\n121: def method_missing(method, *args, &block)\n122: if method.to_s.start_with?('find_by_')\n123: field = method.to_s.sub('find_by_', '')\n124: \"Finding by #{field}: #{args.first}\"\n125: else\n126: super\n127: end\n128: end\n```\n\n### FUNCTION: `respond_to_missing?`\n> Signature: `def respond_to_missing?(method, include_private = false)`\n> Lines: 134-136\n- @brief Declare which dynamic methods respond_to? should recognize.\n- @param method [Symbol] The method name to check.\n- @param include_private [Boolean] Whether to include private methods.\n- @return [Boolean] True if the method is handled dynamically.\n```\n134: def respond_to_missing?(method, include_private = false)\n135: method.to_s.start_with?('find_by_') || super\n136: end\n```\n\n### FUNCTION: `internal_config`\n> Signature: `def internal_config`\n> Lines: 142-144\n- @brief Protected helper for internal computations.\n- @return [Hash] Current options hash.\n```\n142: def internal_config\n143: @options.dup\n144: end\n```\n\n### FUNCTION: `validate!`\n> Signature: `def validate!`\n> Lines: 150-152\n```\n150: def validate!\n151: raise \"Invalid name\" unless valid?\n152: end\n```\n\n### CLASS: `SpecialClass`\n> Signature: `class SpecialClass < MyClass`\n> Lines: 160-174\n- @brief Specialized subclass with additional behavior.\n- @brief Initialize with a priority level.\n- @param name [String] Instance name.\n- @param priority [Integer] Processing priority (lower = first).\n```\n160: class SpecialClass < MyClass\n164: def initialize(name, priority: 0, **options)\n165: super(name, **options)\n166: @priority = priority\n167: end\n171: def to_s\n172: \"SpecialClass(#{@name}, pri=#{@priority})\"\n173: end\n174: end\n```\n\n### FUNCTION: `initialize`\n> Signature: `def initialize(name, priority: 0, **options)`\n> Lines: 164-167\n- @brief Initialize with a priority level.\n- @param name [String] Instance name.\n- @param priority [Integer] Processing priority (lower = first).\n```\n164: def initialize(name, priority: 0, **options)\n165: super(name, **options)\n166: @priority = priority\n167: end\n```\n\n### FUNCTION: `to_s`\n> Signature: `def to_s`\n> Lines: 171-173\n- @brief Override to_s with priority information.\n- @return [String] Description including priority.\n```\n171: def to_s\n172: \"SpecialClass(#{@name}, pri=#{@priority})\"\n173: end\n```\n\n### FUNCTION: `helper`\n> Signature: `def helper`\n> Lines: 183-185\n- @brief Module-level helper returning a boolean.\n- @return [Boolean] Always returns true.\n```\n183: def helper\n184: true\n185: end\n```\n\n### FUNCTION: `process_with_block`\n> Signature: `def process_with_block(data)`\n> Lines: 191-197\n- @brief Process data with block yield pattern.\n- @param data [Object] Data to process.\n@yield [Object] Yields data for caller-defined processing.\n- @return [Object] The block's return value or data itself.\n```\n191: def process_with_block(data)\n192: if block_given?\n193: yield(data)\n194: else\n195: data\n196: end\n197: end\n```\n\n### FUNCTION: `format_list`\n> Signature: `def self.format_list(items)`\n> Lines: 204-206\n- @brief Utility function accessible without mixing in.\n- @param items [Array] Items to format.\n- @return [String] Comma-separated formatted string.\n```\n204: def self.format_list(items)\n205: items.map(&:to_s).join(', ')\n206: end\n```\n\n### FUNCTION: `distance_from_origin`\n> Signature: `def distance_from_origin`\n> Lines: 216-218\n- @brief Compute the Euclidean distance from origin.\n- @return [Float] Distance from (0, 0).\n```\n216: def distance_from_origin\n217: Math.sqrt(x**2 + y**2)\n218: end\n```\n\n### CLASS: `DynamicModel`\n> Signature: `class DynamicModel`\n> Lines: 225-238\n- @brief Demonstrates metaprogramming with define_method.\n- @brief Dynamically defined getter for #{field}.\n```\n225: class DynamicModel\n227: %w[title body author].each do |field|\n229: define_method(field) do\n230: instance_variable_get(\"@#{field}\")\n231: end\n234: define_method(\"#{field}=\") do |value|\n235: instance_variable_set(\"@#{field}\", value)\n236: end\n237: end\n238: end\n```\n\n### FUNCTION: `with_retry`\n> Signature: `def with_retry(attempts: MAX_RETRIES)`\n> Lines: 255-268\n```\n255: def with_retry(attempts: MAX_RETRIES)\n256: tries = 0\n257: begin\n258: tries += 1\n259: yield\n260: rescue StandardError => e\n262: retry if tries < attempts\n263: raise \"Failed after #{attempts} attempts: #{e.message}\"\n264: ensure\n266: puts \"Completed after #{tries} attempt(s)\"\n267: end\n268: end\n```\n\n### FUNCTION: `email?`\n> Signature: `def email?`\n> Lines: 278-280\n- @brief Check if the string is a valid email address.\n- @return [Boolean] True if string matches email pattern.\n```\n278: def email?\n279: match?(/\\A[\\w+\\-.]+@[a-z\\d\\-]+(\\.[a-z\\d\\-]+)*\\.[a-z]+\\z/i)\n280: end\n```\n\n### CLASS: `ServiceObject`\n> Signature: `class ServiceObject; end # inline class comment`\n> Lines: 287-307\n```\n287: class ServiceObject; end\n288: class ReportBuilder; end\n289: module Metrics; end\n290: module Extras; end\n291: MAX_LIMIT = 100\n292: API_VERSION = \"v2\"\n293: CACHE_SIZE = 1024\n294: attr_writer :token\n295: attr_reader :state\n296: require 'yaml'\n297: require 'logger'\n305: def req_cover_ruby_1(value)\n306: value + 1\n307: end\n```\n\n### CLASS: `ReportBuilder`\n> Signature: `class ReportBuilder; end`\n> Lines: 288-307\n```\n288: class ReportBuilder; end\n289: module Metrics; end\n290: module Extras; end\n291: MAX_LIMIT = 100\n292: API_VERSION = \"v2\"\n293: CACHE_SIZE = 1024\n294: attr_writer :token\n295: attr_reader :state\n296: require 'yaml'\n297: require 'logger'\n305: def req_cover_ruby_1(value)\n306: value + 1\n307: end\n```\n\n### DECORATOR: `:token`\n> Lines: 294-294\n```\n294: attr_writer :token\n```\n\n### DECORATOR: `:state`\n> Lines: 295-295\n```\n295: attr_reader :state\n```\n\n### IMPORT: `'yaml'`\n> Lines: 296-296\n```\n296: require 'yaml'\n```\n\n### IMPORT: `'logger'`\n> Lines: 297-297\n```\n297: require 'logger'\n```\n\n### FUNCTION: `req_cover_ruby_1`\n> Signature: `def req_cover_ruby_1(value)`\n> Lines: 305-307\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\n305: def req_cover_ruby_1(value)\n306: value + 1\n307: end\n```\n\n### FUNCTION: `req_cover_ruby_2`\n> Signature: `def req_cover_ruby_2(value)`\n> Lines: 314-316\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\n314: def req_cover_ruby_2(value)\n315: value + 2\n316: end\n```\n\n### FUNCTION: `req_cover_ruby_3`\n> Signature: `def req_cover_ruby_3(value)`\n> Lines: 323-325\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\n323: def req_cover_ruby_3(value)\n324: value + 3\n325: end\n```\n\n### FUNCTION: `req_cover_ruby_4`\n> Signature: `def req_cover_ruby_4(value)`\n> Lines: 332-334\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\n332: def req_cover_ruby_4(value)\n333: value + 4\n334: end\n```\n\n### FUNCTION: `req_cover_ruby_5`\n> Signature: `def req_cover_ruby_5(value)`\n> Lines: 341-343\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\n341: def req_cover_ruby_5(value)\n342: value + 5\n343: end\n```\n\n@@@ <PROJECT_BASE>/src/fixture_rust.rs | rust\n\n### IMPORT: `std::io`\n> Lines: 9-9\n```\n9: use std::io;\n```\n\n### IMPORT: `std::collections::HashMap`\n> Lines: 10-10\n```\n10: use std::collections::HashMap;\n```\n\n### IMPORT: `std::fmt::{self, Display, Formatter}`\n> Lines: 11-11\n```\n11: use std::fmt::{self, Display, Formatter};\n```\n\n### IMPORT: `std::sync::{Arc, Mutex}`\n> Lines: 12-12\n```\n12: use std::sync::{Arc, Mutex};\n```\n\n### DECORATOR: `derive(Debug, Clone, PartialEq)`\n> Lines: 19-19\n- @brief Holds a single i32 field with Debug/Clone derives.\n```\n19: #[derive(Debug, Clone, PartialEq)]\n```\n\n### DECORATOR: `derive(Debug)`\n> Lines: 29-29\n```\n29: #[derive(Debug)]\n```\n\n### FUNCTION: `do_work`\n> Signature: `fn do_work(&self)`\n> Lines: 67-78\n```\n67: fn do_work(&self);\n73: fn do_work_with_ctx(&self, ctx: &str) -> bool {\n75: println!(\"ctx: {}\", ctx);\n76: self.do_work();\n77: true\n78: }\n```\n\n### FUNCTION: `do_work_with_ctx`\n> Signature: `fn do_work_with_ctx(&self, ctx: &str) -> bool`\n> Lines: 73-78\n- @param ctx Contextual string passed to the implementation.\n- @return True if work completed successfully.\n```\n73: fn do_work_with_ctx(&self, ctx: &str) -> bool {\n75: println!(\"ctx: {}\", ctx);\n76: self.do_work();\n77: true\n78: }\n```\n\n### FUNCTION: `parse`\n> Signature: `fn parse(&self, input: &'a [u8]) -> Result<Self::Output, io::Error>`\n> Lines: 93-96\n- @param input Byte slice to parse.\n- @return Parsed output or an IO error.\n```\n93: fn parse(&self, input: &'a [u8]) -> Result<Self::Output, io::Error>;\n94: }\n96: impl MyStruct {\n```\n\n### FUNCTION: `new`\n> Signature: `fn new() -> Self`\n> Lines: 100-102\n- @return A MyStruct with field initialized to 0.\n```\n100: fn new() -> Self {\n101: Self { field: 0 }\n102: }\n```\n\n### FUNCTION: `with_value`\n> Signature: `pub fn with_value(val: i32) -> Self`\n> Lines: 108-110\n- @param val The initial field value.\n- @return A new MyStruct.\n```\n108: pub fn with_value(val: i32) -> Self {\n109: Self { field: val }\n110: }\n```\n\n### FUNCTION: `value`\n> Signature: `pub fn value(&self) -> i32`\n> Lines: 115-117\n- @return The stored integer.\n```\n115: pub fn value(&self) -> i32 {\n116: self.field\n117: }\n```\n\n### FUNCTION: `try_update`\n> Signature: `pub fn try_update(&mut self, new_val: i32) -> Option<i32>`\n> Lines: 123-131\n- @param new_val New value to set.\n- @return Old value if updated, None if new_val equals current.\n```\n123: pub fn try_update(&mut self, new_val: i32) -> Option<i32> {\n124: if new_val == self.field {\n125: return None;\n126: }\n127: let old = self.field;\n128: self.field = new_val;\n130: Some(old)\n131: }\n```\n\n### FUNCTION: `do_work`\n> Signature: `fn do_work(&self)`\n> Lines: 136-138\n```\n136: fn do_work(&self) {\n137: println!(\"{:?}\", self);\n138: }\n```\n\n### FUNCTION: `fmt`\n> Signature: `fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result`\n> Lines: 146-148\n- @param f Formatter to write into.\n- @return fmt::Result indicating success or failure.\n```\n146: fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {\n147: write!(f, \"MyStruct({})\", self.field)\n148: }\n```\n\n### FUNCTION: `insert`\n> Signature: `pub fn insert(&mut self, key: K, value: V) -> Option<V>`\n> Lines: 163-165\n- @param key The lookup key.\n- @param value The value to associate with the key.\n- @return Previous value for this key, or None.\n```\n163: pub fn insert(&mut self, key: K, value: V) -> Option<V> {\n164: self.inner.insert(key, value)\n165: }\n```\n\n### FUNCTION: `get_or_default`\n> Signature: `pub fn get_or_default(&self, key: &K) -> V`\n> Lines: 171-176\n- @param key The key to look up.\n- @return Cloned value if found, or the default for V.\n```\n171: pub fn get_or_default(&self, key: &K) -> V {\n172: match self.inner.get(key) {\n173: Some(v) => v.clone(),\n174: None => V::default(),\n175: }\n176: }\n```\n\n### FUNCTION: `my_function`\n> Signature: `pub fn my_function(input: Option<&str>) -> String`\n> Lines: 240-249\n- @param input Optional string to evaluate.\n- @return Processed string or a fallback default.\n```\n240: pub fn my_function(input: Option<&str>) -> String {\n242: let text = match input {\n243: Some(s) if !s.is_empty() => s,\n244: Some(_) => return String::from(\"empty\"),\n245: None => return String::from(\"none\"),\n246: };\n248: text.to_uppercase()\n249: }\n```\n\n### FUNCTION: `async_function`\n> Signature: `pub async fn async_function() -> String`\n> Lines: 254-257\n- @return A greeting string after async computation.\n```\n254: pub async fn async_function() -> String {\n256: String::from(\"hello async\")\n257: }\n```\n\n### FUNCTION: `filter_with`\n> Signature: `pub fn filter_with<F>(items: &[i32], predicate: F) -> Vec<i32>`\n> Lines: 264-269\n- @param items Slice of integers to filter.\n- @param predicate Closure returning true for items to keep.\n- @return Vector of items passing the predicate.\n```\n264: pub fn filter_with<F>(items: &[i32], predicate: F) -> Vec<i32>\n265: where\n266: F: Fn(&i32) -> bool,\n267: {\n268: items.iter().copied().filter(|x| predicate(x)).collect()\n269: }\n```\n\n### FUNCTION: `create_worker`\n> Signature: `pub fn create_worker(use_struct: bool) -> Box<dyn MyTrait>`\n> Lines: 275-281\n- @param use_struct If true, returns MyStruct; otherwise panics.\n- @return A heap-allocated trait object implementing MyTrait.\n```\n275: pub fn create_worker(use_struct: bool) -> Box<dyn MyTrait> {\n276: if use_struct {\n277: Box::new(MyStruct::new())\n278: } else {\n279: panic!(\"No alternative implementation available\");\n280: }\n281: }\n```\n\n### FUNCTION: `read_raw`\n> Signature: `pub unsafe fn read_raw(ptr: *const i32) -> i32`\n> Lines: 288-291\n- @param ptr Raw pointer to an i32 value.\n- @return The value pointed to by ptr.\n- @sa fety Caller must ensure ptr is valid and aligned.\n```\n288: pub unsafe fn read_raw(ptr: *const i32) -> i32 {\n290: *ptr\n291: }\n```\n\n### FUNCTION: `ffi_double`\n> Signature: `pub extern \"C\" fn ffi_double(x: i32) -> i32`\n> Lines: 297-299\n- @param x Integer to double.\n- @return The input multiplied by 2.\n```\n297: pub extern \"C\" fn ffi_double(x: i32) -> i32 {\n298: x * 2\n299: }\n```\n\n### FUNCTION: `describe_enum`\n> Signature: `pub fn describe_enum(val: &MyEnum) -> String`\n> Lines: 305-315\n- @param val An enum variant to match against.\n- @return A description string for the matched variant.\n```\n305: pub fn describe_enum(val: &MyEnum) -> String {\n306: match val {\n307: MyEnum::A => String::from(\"unit\"),\n308: MyEnum::B(s) => format!(\"string: {}\", s),\n309: MyEnum::C { x, y } => {\n311: let mag = ((x * x + y * y) as f64).sqrt();\n312: format!(\"point({}, {}) mag={:.2}\", x, y, mag)\n313: }\n314: }\n315: }\n```\n\n### IMPORT: `std::time::Duration`\n> Lines: 318-318\n```\n318: use std::time::Duration;\n```\n\n### DECORATOR: `inline`\n> Lines: 322-322\n```\n322: #[inline]\n```\n\n### DECORATOR: `allow(dead_code)`\n> Lines: 323-323\n```\n323: #[allow(dead_code)]\n```\n\n### DECORATOR: `cfg(test)`\n> Lines: 324-324\n```\n324: #[cfg(test)]\n```\n\n### FUNCTION: `req_cover_rust_1`\n> Signature: `fn req_cover_rust_1(value: i32) -> i32 { value + 1 }`\n> Lines: 350-350\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\n350: fn req_cover_rust_1(value: i32) -> i32 { value + 1 }\n```\n\n### FUNCTION: `req_cover_rust_2`\n> Signature: `fn req_cover_rust_2(value: i32) -> i32 { value + 2 }`\n> Lines: 357-357\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\n357: fn req_cover_rust_2(value: i32) -> i32 { value + 2 }\n```\n\n### FUNCTION: `req_cover_rust_3`\n> Signature: `fn req_cover_rust_3(value: i32) -> i32 { value + 3 }`\n> Lines: 364-364\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\n364: fn req_cover_rust_3(value: i32) -> i32 { value + 3 }\n```\n\n### FUNCTION: `req_cover_rust_4`\n> Signature: `fn req_cover_rust_4(value: i32) -> i32 { value + 4 }`\n> Lines: 371-371\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\n371: fn req_cover_rust_4(value: i32) -> i32 { value + 4 }\n```\n\n### FUNCTION: `req_cover_rust_5`\n> Signature: `fn req_cover_rust_5(value: i32) -> i32 { value + 5 }`\n> Lines: 378-378\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\n378: fn req_cover_rust_5(value: i32) -> i32 { value + 5 }\n```\n\n@@@ <PROJECT_BASE>/src/fixture_scala.scala | scala\n- @brief Comprehensive Scala test fixture for parser validation.\n- @details Covers implicits/givens, pattern matching, higher-kinded types,\nself-types, variance, opaque types, extension methods, enums,\nfor comprehensions, and cake pattern.\n\n### IMPORT: `scala.collection.mutable`\n> Lines: 11-11\n```\n11: import scala.collection.mutable\n```\n\n### IMPORT: `scala.concurrent.{Future, ExecutionContext}`\n> Lines: 12-12\n```\n12: import scala.concurrent.{Future, ExecutionContext}\n```\n\n### IMPORT: `scala.util.{Try, Success, Failure}`\n> Lines: 13-13\n```\n13: import scala.util.{Try, Success, Failure}\n```\n\n### CLASS: `Person`\n> Signature: `case class Person(name: String, age: Int)`\n> Lines: 23-35\n- @brief Immutable data class for person entities.\n- @brief Check if the person is an adult.\n- @param name Display name.\n- @param age Age in years; must be non-negative.\n- @return True if age >= 18.\n```\n23: case class Person(name: String, age: Int) {\n28: def isAdult: Boolean = age >= 18\n34: def greet: String = s\"Hi, I'm $name, age $age\"\n35: }\n```\n\n### FUNCTION: `isAdult`\n> Signature: `def isAdult: Boolean = age >= 18`\n> Lines: 28-43\n- @brief Check if the person is an adult.\n- @brief Create a greeting string.\n- @return True if age >= 18.\n- @return Formatted greeting including name and age.\n```\n28: def isAdult: Boolean = age >= 18\n34: def greet: String = s\"Hi, I'm $name, age $age\"\n35: }\n43: sealed trait Shape {\n```\n\n### FUNCTION: `greet`\n> Signature: `def greet: String = s\"Hi, I'm $name, age $age\"`\n> Lines: 34-43\n- @brief Create a greeting string.\n- @return Formatted greeting including name and age.\n```\n34: def greet: String = s\"Hi, I'm $name, age $age\"\n35: }\n43: sealed trait Shape {\n```\n\n### FUNCTION: `area`\n> Signature: `def area: Double`\n> Lines: 48-56\n- @brief Compute the area of this shape.\n- @brief Circle shape with radius.\n- @param radius The circle's radius.\n- @return Area as a Double.\n```\n48: def area: Double\n49: }\n56: case class Circle(radius: Double) extends Shape {\n```\n\n### CLASS: `Circle`\n> Signature: `case class Circle(radius: Double) extends Shape`\n> Lines: 56-58\n- @brief Circle shape with radius.\n- @param radius The circle's radius.\n```\n56: case class Circle(radius: Double) extends Shape {\n57: override def area: Double = math.Pi * radius * radius\n58: }\n```\n\n### FUNCTION: `area`\n> Signature: `override def area: Double = math.Pi * radius * radius`\n> Lines: 57-66\n- @brief Rectangle shape with width and height.\n- @param width The rectangle's width.\n- @param height The rectangle's height.\n```\n57: override def area: Double = math.Pi * radius * radius\n58: }\n66: case class Rectangle(width: Double, height: Double) extends Shape {\n```\n\n### CLASS: `Rectangle`\n> Signature: `case class Rectangle(width: Double, height: Double) extends Shape`\n> Lines: 66-68\n- @brief Rectangle shape with width and height.\n- @param width The rectangle's width.\n- @param height The rectangle's height.\n```\n66: case class Rectangle(width: Double, height: Double) extends Shape {\n67: override def area: Double = width * height\n68: }\n```\n\n### FUNCTION: `area`\n> Signature: `override def area: Double = width * height`\n> Lines: 67-76\n```\n67: override def area: Double = width * height\n68: }\n76: abstract class Animal {\n```\n\n### CLASS: `Animal`\n> Signature: `abstract class Animal`\n> Lines: 76-88\n- @brief Abstract base class for animals with sound production.\n- @brief The sound this animal makes.\n- @return Sound description string.\n```\n76: abstract class Animal {\n81: def sound: String\n87: def describe: String = s\"I am a ${getClass.getSimpleName} and I say $sound\"\n88: }\n```\n\n### FUNCTION: `sound`\n> Signature: `def sound: String`\n> Lines: 81-87\n- @brief The sound this animal makes.\n- @brief Describe the animal including its sound.\n- @return Sound description string.\n- @return Formatted description string.\n```\n81: def sound: String\n87: def describe: String = s\"I am a ${getClass.getSimpleName} and I say $sound\"\n```\n\n### FUNCTION: `describe`\n> Signature: `def describe: String = s\"I am a ${getClass.getSimpleName} and I say $sound\"`\n> Lines: 87-87\n- @brief Describe the animal including its sound.\n- @return Formatted description string.\n```\n87: def describe: String = s\"I am a ${getClass.getSimpleName} and I say $sound\"\n```\n\n### FUNCTION: `draw`\n> Signature: `def draw(): Unit`\n> Lines: 101-109\n- @brief Draw the object as a string.\n- @brief Self-type trait requiring Drawable to be mixed in.\n- @details Demonstrates the cake pattern for dependency injection.\n- @return Rendered string representation.\n```\n101: def draw(): Unit\n102: }\n109: trait Logging { self: Drawable =>\n```\n\n### FUNCTION: `logAndDraw`\n> Signature: `def logAndDraw(): Unit =`\n> Lines: 113-116\n- @brief Log the drawing operation and then draw.\n```\n113: def logAndDraw(): Unit = {\n114: println(\"About to draw\")\n115: draw()\n116: }\n```\n\n### FUNCTION: `serialize`\n> Signature: `def serialize: Array[Byte]`\n> Lines: 128-137\n- @brief Serialize this object to bytes.\n- @return Byte array representation.\n```\n128: def serialize: Array[Byte]\n129: }\n137: object Main {\n```\n\n### FUNCTION: `main`\n> Signature: `def main(args: Array[String]): Unit =`\n> Lines: 142-147\n- @brief Application entry point.\n- @param args Command-line arguments.\n```\n142: def main(args: Array[String]): Unit = {\n143: val people = List(Person(\"Alice\", 30), Person(\"Bob\", 17))\n145: val adults = people.filter(_.isAdult)\n146: adults.foreach(p => println(p.greet))\n147: }\n```\n\n### FUNCTION: `toString`\n> Signature: `override def toString: String = \"Main\"`\n> Lines: 153-179\n- @brief Override toString for Main object display.\n- @brief Mathematical constant pi.\n- @return String representation.\n```\n153: override def toString: String = \"Main\"\n156: val pi = 3.14159265\n159: var counter = 0\n164: type StringList = List[String]\n169: type Transformer[A] = A => A\n176: def describeShape(shape: Shape): String = shape match {\n177: case Circle(r) => s\"Circle with radius $r, area=${shape.area}\"\n178: case Rectangle(w, h) => s\"Rectangle ${w}x${h}, area=${shape.area}\"\n179: }\n```\n\n### VARIABLE: `counter`\n> Signature: `var counter = 0`\n> Lines: 159-159\n- @brief Mutable counter for tracking operations. */\n```\n159: var counter = 0\n```\n\n### FUNCTION: `describeShape`\n> Signature: `def describeShape(shape: Shape): String = shape match`\n> Lines: 176-179\n- @brief Describe a shape using exhaustive pattern matching.\n- @param shape The shape to describe.\n- @return Human-readable description with area.\n```\n176: def describeShape(shape: Shape): String = shape match {\n177: case Circle(r) => s\"Circle with radius $r, area=${shape.area}\"\n178: case Rectangle(w, h) => s\"Rectangle ${w}x${h}, area=${shape.area}\"\n179: }\n```\n\n### FUNCTION: `classify`\n> Signature: `def classify(x: Int): String = x match`\n> Lines: 186-191\n- @brief Process a value with multiple match guards.\n- @param x Integer input to classify.\n- @return Classification string.\n```\n186: def classify(x: Int): String = x match {\n187: case 0 => \"zero\"\n188: case n if n < 0 => \"negative\"\n189: case n if n > 100 => \"large\"\n190: case _ => \"positive\"\n191: }\n```\n\n### CLASS: `Config`\n> Signature: `class Config private (val entries: Map[String, String])`\n> Lines: 201-208\n- @brief Configuration holder with companion factory.\n- @brief Retrieve a value by key.\n- @param entries Key-value pairs.\n- @param key The configuration key.\n- @return Optional value.\n```\n201: class Config private (val entries: Map[String, String]) {\n207: def get(key: String): Option[String] = entries.get(key)\n208: }\n```\n\n### FUNCTION: `get`\n> Signature: `def get(key: String): Option[String] = entries.get(key)`\n> Lines: 207-214\n- @brief Retrieve a value by key.\n- @brief Companion object with factory methods for Config.\n- @param key The configuration key.\n- @return Optional value.\n```\n207: def get(key: String): Option[String] = entries.get(key)\n208: }\n214: object Config {\n```\n\n### FUNCTION: `apply`\n> Signature: `def apply(entries: (String, String)*): Config = new Config(entries.toMap)`\n> Lines: 220-236\n- @brief Create a Config from key-value pairs.\n- @brief Create an empty Config.\n- @param entries Variable number of key-value tuples.\n- @return A new Config instance.\n- @return Config with no entries.\n```\n220: def apply(entries: (String, String)*): Config = new Config(entries.toMap)\n226: def empty: Config = new Config(Map.empty)\n227: }\n236: class Container[+A](val value: A) {\n```\n\n### FUNCTION: `empty`\n> Signature: `def empty: Config = new Config(Map.empty)`\n> Lines: 226-236\n- @brief Create an empty Config.\n- @return Config with no entries.\n```\n226: def empty: Config = new Config(Map.empty)\n227: }\n236: class Container[+A](val value: A) {\n```\n\n### CLASS: `Container`\n> Signature: `class Container[+A](val value: A)`\n> Lines: 236-252\n- @brief Covariant generic container.\n@tparam +A Element type (covariant).\n- @brief Map the contained value. @tparam B Target type.\n- @param f Transform function.\n- @return New Container with transformed value.\n```\n236: class Container[+A](val value: A) {\n243: def map[B](f: A => B): Container[B] = new Container(f(value))\n251: def flatMap[B](f: A => Container[B]): Container[B] = f(value)\n252: }\n```\n\n### FUNCTION: `map`\n> Signature: `def map[B](f: A => B): Container[B] = new Container(f(value))`\n> Lines: 243-261\n- @brief Map the contained value.\n@tparam B Target type.\n- @brief Flat-map the contained value. @tparam B Target type.\n- @param f Transform function.\n- @param f Transform function returning a Container.\n- @return New Container with transformed value.\n- @return Flattened Container.\n```\n243: def map[B](f: A => B): Container[B] = new Container(f(value))\n251: def flatMap[B](f: A => Container[B]): Container[B] = f(value)\n252: }\n261: implicit class RichInt(val n: Int) extends AnyVal {\n```\n\n### FUNCTION: `flatMap`\n> Signature: `def flatMap[B](f: A => Container[B]): Container[B] = f(value)`\n> Lines: 251-261\n- @brief Flat-map the contained value.\n@tparam B Target type.\n- @param f Transform function returning a Container.\n- @return Flattened Container.\n```\n251: def flatMap[B](f: A => Container[B]): Container[B] = f(value)\n252: }\n261: implicit class RichInt(val n: Int) extends AnyVal {\n```\n\n### FUNCTION: `isEven`\n> Signature: `def isEven: Boolean = n % 2 == 0`\n> Lines: 266-282\n- @brief Check if the number is even.\n- @brief Repeat a string n times.\n- @param s The string to repeat.\n- @return True if n is divisible by 2.\n- @return Concatenated result.\n```\n266: def isEven: Boolean = n % 2 == 0\n273: def times(s: String): String = s * n\n274: }\n282: object ForCompExample {\n```\n\n### FUNCTION: `times`\n> Signature: `def times(s: String): String = s * n`\n> Lines: 273-282\n- @brief Repeat a string n times.\n- @param s The string to repeat.\n- @return Concatenated result.\n```\n273: def times(s: String): String = s * n\n274: }\n282: object ForCompExample {\n```\n\n### FUNCTION: `findPairs`\n> Signature: `def findPairs(range: Int, target: Int): List[(Int, Int)] =`\n> Lines: 289-295\n- @brief Compute all pairs of integers whose sum equals target.\n- @param range Upper bound of the search space.\n- @param target Desired sum.\n- @return List of pairs summing to target.\n```\n289: def findPairs(range: Int, target: Int): List[(Int, Int)] = {\n290: for {\n291: x <- (1 to range).toList\n292: y <- (x to range).toList\n293: if x + y == target\n294: } yield (x, y)\n295: }\n```\n\n### FUNCTION: `add`\n> Signature: `def add(a: Int)(b: Int): Int = a + b`\n> Lines: 311-351\n- @brief Curried addition function.\n- @brief Apply a function twice to an initial value. @tparam A Value type.\n- @param a First operand.\n- @param b Second operand.\n- @param f Function to apply.\n- @param x Initial value.\n- @return Sum of a and b.\n- @return Result of f(f(x)).\n```\n311: def add(a: Int)(b: Int): Int = a + b\n320: def twice[A](f: A => A)(x: A): A = f(f(x))\n331: def compose[A, B, C](f: A => B, g: B => C): A => C = a => g(f(a))\n332: }\n335: import scala.util.Random\n336: import scala.concurrent.duration._\n337: trait Runner\n338: trait Parser\n339: object Metrics\n340: val MaxUsers = 100\n341: val RetryLimit = 3\n342: type UserKey = String\n343: type ErrorCode = Int\n344: type Mapper = String => String\n345: var attempts = 0\n346: var cursor = 1\n347: var stage = \"init\"\n348: var status = \"ready\"\n351: object ReqCoverScala {\n```\n\n### FUNCTION: `twice`\n> Signature: `def twice[A](f: A => A)(x: A): A = f(f(x))`\n> Lines: 320-351\n- @brief Apply a function twice to an initial value.\n@tparam A Value type.\n- @brief Compose two functions left to right. @tparam A Input type. @tparam B Intermediate type. @tparam C Output type.\n- @param f Function to apply.\n- @param x Initial value.\n- @param f First function.\n- @param g Second function.\n- @return Result of f(f(x)).\n- @return Composed function.\n```\n320: def twice[A](f: A => A)(x: A): A = f(f(x))\n331: def compose[A, B, C](f: A => B, g: B => C): A => C = a => g(f(a))\n332: }\n335: import scala.util.Random\n336: import scala.concurrent.duration._\n337: trait Runner\n338: trait Parser\n339: object Metrics\n340: val MaxUsers = 100\n341: val RetryLimit = 3\n342: type UserKey = String\n343: type ErrorCode = Int\n344: type Mapper = String => String\n345: var attempts = 0\n346: var cursor = 1\n347: var stage = \"init\"\n348: var status = \"ready\"\n351: object ReqCoverScala {\n```\n\n### FUNCTION: `compose`\n> Signature: `def compose[A, B, C](f: A => B, g: B => C): A => C = a => g(f(a))`\n> Lines: 331-351\n- @brief Compose two functions left to right.\n@tparam A Input type.\n@tparam B Intermediate type.\n@tparam C Output type.\n- @param f First function.\n- @param g Second function.\n- @return Composed function.\n```\n331: def compose[A, B, C](f: A => B, g: B => C): A => C = a => g(f(a))\n332: }\n335: import scala.util.Random\n336: import scala.concurrent.duration._\n337: trait Runner\n338: trait Parser\n339: object Metrics\n340: val MaxUsers = 100\n341: val RetryLimit = 3\n342: type UserKey = String\n343: type ErrorCode = Int\n344: type Mapper = String => String\n345: var attempts = 0\n346: var cursor = 1\n347: var stage = \"init\"\n348: var status = \"ready\"\n351: object ReqCoverScala {\n```\n\n### IMPORT: `scala.util.Random`\n> Lines: 335-335\n```\n335: import scala.util.Random\n```\n\n### IMPORT: `scala.concurrent.duration._`\n> Lines: 336-336\n```\n336: import scala.concurrent.duration._\n```\n\n### VARIABLE: `attempts`\n> Signature: `var attempts = 0`\n> Lines: 345-345\n```\n345: var attempts = 0\n```\n\n### VARIABLE: `cursor`\n> Signature: `var cursor = 1`\n> Lines: 346-346\n```\n346: var cursor = 1\n```\n\n### VARIABLE: `stage`\n> Signature: `var stage = \"init\"`\n> Lines: 347-347\n```\n347: var stage = \"init\"\n```\n\n### VARIABLE: `status`\n> Signature: `var status = \"ready\"`\n> Lines: 348-348\n```\n348: var status = \"ready\"\n```\n\n### FUNCTION: `reqCoverScala1`\n> Signature: `def reqCoverScala1(value: Int): Int = value + 1`\n> Lines: 359-359\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\n359: def reqCoverScala1(value: Int): Int = value + 1\n```\n\n### FUNCTION: `reqCoverScala2`\n> Signature: `def reqCoverScala2(value: Int): Int = value + 2`\n> Lines: 368-368\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\n368: def reqCoverScala2(value: Int): Int = value + 2\n```\n\n### FUNCTION: `reqCoverScala3`\n> Signature: `def reqCoverScala3(value: Int): Int = value + 3`\n> Lines: 377-377\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\n377: def reqCoverScala3(value: Int): Int = value + 3\n```\n\n### FUNCTION: `reqCoverScala4`\n> Signature: `def reqCoverScala4(value: Int): Int = value + 4`\n> Lines: 386-386\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\n386: def reqCoverScala4(value: Int): Int = value + 4\n```\n\n### FUNCTION: `reqCoverScala5`\n> Signature: `def reqCoverScala5(value: Int): Int = value + 5`\n> Lines: 395-395\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\n395: def reqCoverScala5(value: Int): Int = value + 5\n```\n\n@@@ <PROJECT_BASE>/src/fixture_shell.sh | shell\n\n### VARIABLE: `MY_VAR`\n> Signature: `MY_VAR=\"hello\"`\n> Lines: 12-12\n- @brief Greeting message template.\n```\n12: MY_VAR=\"hello\"\n```\n\n### VARIABLE: `PATH_EXT`\n> Signature: `export PATH_EXT=\"/usr/local/bin\"`\n> Lines: 15-15\n- @brief Extended PATH including local binary directory.\n```\n15: export PATH_EXT=\"/usr/local/bin\"\n```\n\n### VARIABLE: `MAX_COUNT`\n> Signature: `readonly MAX_COUNT=10`\n> Lines: 18-18\n- @brief Immutable maximum iteration counter.\n```\n18: readonly MAX_COUNT=10\n```\n\n### VARIABLE: `BUILD_VERSION`\n> Signature: `declare -r BUILD_VERSION=\"1.0.0\"`\n> Lines: 21-21\n- @brief Build version set via declare.\n```\n21: declare -r BUILD_VERSION=\"1.0.0\"\n```\n\n### VARIABLE: `DEBUG_MODE`\n> Signature: `DEBUG_MODE=0`\n> Lines: 24-24\n- @brief Debug mode flag (0=off, 1=on).\n```\n24: DEBUG_MODE=0\n```\n\n### VARIABLE: `LANGUAGES`\n> Signature: `declare -a LANGUAGES=(\"python\" \"rust\" \"go\" \"java\" \"typescript\")`\n> Lines: 29-29\n- @brief Indexed array of supported languages.\n```\n29: declare -a LANGUAGES=(\"python\" \"rust\" \"go\" \"java\" \"typescript\")\n```\n\n### VARIABLE: `EXT_MAP`\n> Signature: `declare -A EXT_MAP=(`\n> Lines: 32-32\n- @brief Associative array mapping extensions to languages.\n```\n32: declare -A EXT_MAP=(\n```\n\n### FUNCTION: `greet`\n> Signature: `function greet()`\n> Lines: 44-44\n- @brief Greet a user by name on stdout.\n- @param $1 The user's name.\n```\n44: function greet() {\n```\n\n### FUNCTION: `cleanup`\n> Signature: `cleanup()`\n> Lines: 56-56\n- @brief Remove temporary files and directories.\n- @details Called by trap on EXIT for cleanup.\n```\n56: cleanup() {\n```\n\n### FUNCTION: `parse_args`\n> Signature: `parse_args()`\n> Lines: 68-68\n- @brief Parse command-line options using getopts.\n- @param $@ Command-line arguments.\n- @return Sets global variables based on parsed options.\n```\n68: parse_args() {\n```\n\n### VARIABLE: `VERBOSE`\n> Signature: `VERBOSE=1`\n> Lines: 74-74\n```\n74: VERBOSE=1\n```\n\n### VARIABLE: `DEBUG_MODE`\n> Signature: `DEBUG_MODE=1`\n> Lines: 78-78\n```\n78: DEBUG_MODE=1\n```\n\n### VARIABLE: `INPUT_FILE`\n> Signature: `INPUT_FILE=\"$OPTARG\"`\n> Lines: 82-82\n```\n82: INPUT_FILE=\"$OPTARG\"\n```\n\n### VARIABLE: `OUTPUT_FILE`\n> Signature: `OUTPUT_FILE=\"$OPTARG\"`\n> Lines: 86-86\n```\n86: OUTPUT_FILE=\"$OPTARG\"\n```\n\n### FUNCTION: `process_file`\n> Signature: `process_file()`\n> Lines: 105-105\n- @brief Process a file with error handling and logging.\n- @param $1 Path to the input file.\n- @param $2 Optional output path (defaults to stdout).\n- @return 0 on success, 1 on failure.\n```\n105: process_file() {\n```\n\n### FUNCTION: `retry_command`\n> Signature: `retry_command()`\n> Lines: 139-139\n- @brief Execute a command with retry logic.\n- @param $1 Maximum number of retry attempts.\n- @param $@ The command and arguments to execute.\n- @return Exit code of the final attempt.\n```\n139: retry_command() {\n```\n\n### FUNCTION: `log_message`\n> Signature: `log_message()`\n> Lines: 162-162\n- @brief Log a message with timestamp prefix.\n- @param $1 Log level (INFO, WARN, ERROR).\n- @param $@ Message text.\n```\n162: log_message() {\n```\n\n### FUNCTION: `make_temp`\n> Signature: `make_temp()`\n> Lines: 172-172\n- @brief Generate a temporary file and return its path.\n- @return Path to the created temporary file.\n```\n172: make_temp() {\n```\n\n### FUNCTION: `generate_config`\n> Signature: `generate_config()`\n> Lines: 189-189\n- @brief Generate a configuration file using heredoc.\n```\n189: generate_config() {\n```\n\n### FUNCTION: `factorial`\n> Signature: `factorial()`\n> Lines: 203-203\n- @brief Compute factorial iteratively.\n- @param $1 Non-negative integer.\n- @return Factorial result.\n```\n203: factorial() {\n```\n\n### IMPORT: `./config.sh`\n> Lines: 218-218\n- @brief Load external configuration script if present.\n```\n218: source ./config.sh\n```\n\n### IMPORT: `./env.sh`\n> Lines: 222-222\n```\n222: source ./env.sh\n```\n\n### IMPORT: `./shared.sh`\n> Lines: 224-224\n```\n224: source ./shared.sh\n```\n\n### IMPORT: `./runtime.sh`\n> Lines: 226-226\n```\n226: source ./runtime.sh\n```\n\n### IMPORT: `./network.sh`\n> Lines: 228-228\n```\n228: source ./network.sh\n```\n\n### FUNCTION: `req_cover_shell_1`\n> Signature: `req_cover_shell_1()`\n> Lines: 236-236\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\n236: req_cover_shell_1() {\n```\n\n### FUNCTION: `req_cover_shell_2`\n> Signature: `req_cover_shell_2()`\n> Lines: 245-245\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\n245: req_cover_shell_2() {\n```\n\n### FUNCTION: `req_cover_shell_3`\n> Signature: `req_cover_shell_3()`\n> Lines: 254-254\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\n254: req_cover_shell_3() {\n```\n\n### FUNCTION: `req_cover_shell_4`\n> Signature: `req_cover_shell_4()`\n> Lines: 263-263\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\n263: req_cover_shell_4() {\n```\n\n### FUNCTION: `req_cover_shell_5`\n> Signature: `req_cover_shell_5()`\n> Lines: 272-272\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\n272: req_cover_shell_5() {\n```\n\n@@@ <PROJECT_BASE>/src/fixture_swift.swift | swift\n\n### IMPORT: `Foundation`\n> Lines: 8-8\n```\n8: import Foundation\n```\n\n### IMPORT: `Combine`\n> Lines: 9-9\n```\n9: import Combine\n```\n\n### CLASS: `Animal`\n> Signature: `class Animal`\n> Lines: 16-58\n- @brief Base class with stored, computed, and observed properties.\n- @brief Species name identifier.\n```\n16: class Animal {\n18: var species: String\n21: var legs: Int = 4 {\n22: willSet {\n24: print(\"Legs changing from \\(legs) to \\(newValue)\")\n25: }\n26: didSet {\n28: if legs < 0 { legs = 0 }\n29: }\n30: }\n33: var description: String {\n34: return \"\\(species) with \\(legs) legs\"\n35: }\n39: init(species: String) {\n40: self.species = species\n41: }\n44: func speak() {\n45: print(\"...\")\n46: }\n50: class func createDefault() -> Animal {\n51: return Animal(species: \"Unknown\")\n52: }\n55: deinit {\n56: print(\"\\(species) deallocated\")\n57: }\n58: }\n```\n\n### VARIABLE: `species`\n> Signature: `var species: String`\n> Lines: 18-18\n- @brief Species name identifier.\n```\n18: var species: String\n```\n\n### VARIABLE: `legs`\n> Signature: `var legs: Int = 4`\n> Lines: 21-21\n- @brief Number of legs; triggers a didSet observer on change.\n```\n21: var legs: Int = 4 {\n```\n\n### VARIABLE: `description`\n> Signature: `var description: String`\n> Lines: 33-33\n- @brief Computed property returning a descriptive string.\n```\n33: var description: String {\n```\n\n### FUNCTION: `speak`\n> Signature: `func speak()`\n> Lines: 44-46\n- @brief Produce a sound; subclasses should override.\n```\n44: func speak() {\n45: print(\"...\")\n46: }\n```\n\n### CLASS: `func`\n> Signature: `class func createDefault() -> Animal`\n> Lines: 50-52\n- @brief Class method creating a generic instance.\n- @return An Animal with species \"Unknown\".\n```\n50: class func createDefault() -> Animal {\n51: return Animal(species: \"Unknown\")\n52: }\n```\n\n### CLASS: `Dog`\n> Signature: `class Dog: Animal`\n> Lines: 63-78\n- @brief Concrete animal with dog-specific behavior.\n- @brief Dog's name.\n```\n63: class Dog: Animal {\n65: let name: String\n69: init(name: String) {\n70: self.name = name\n71: super.init(species: \"Dog\")\n72: }\n75: override func speak() {\n76: print(\"\\(name) says: Woof!\")\n77: }\n78: }\n```\n\n### FUNCTION: `speak`\n> Signature: `override func speak()`\n> Lines: 75-77\n- @brief Override speak to produce dog-specific sound.\n```\n75: override func speak() {\n76: print(\"\\(name) says: Woof!\")\n77: }\n```\n\n### VARIABLE: `x`\n> Signature: `var x: Double = 0.0`\n> Lines: 86-86\n```\n86: var x: Double = 0.0\n```\n\n### VARIABLE: `y`\n> Signature: `var y: Double = 0.0`\n> Lines: 87-87\n```\n87: var y: Double = 0.0\n```\n\n### VARIABLE: `magnitude`\n> Signature: `var magnitude: Double`\n> Lines: 99-99\n- @brief Compute Euclidean distance from origin.\n- @return Distance as a Double.\n```\n99: var magnitude: Double {\n```\n\n### VARIABLE: `data`\n> Signature: `private var data: [[Double]]`\n> Lines: 109-109\n- @brief Flat storage for matrix values.\n```\n109: private var data: [[Double]]\n```\n\n### VARIABLE: `opposite`\n> Signature: `var opposite: Direction`\n> Lines: 148-148\n- @brief Compute the opposite direction.\n- @return The direction 180 degrees from self.\n```\n148: var opposite: Direction {\n```\n\n### FUNCTION: `map`\n> Signature: `func map<U>(_ transform: (T) -> U) -> AppResult<U>`\n> Lines: 171-178\n- @brief Map the success value using a transform closure.\n- @param transform Closure converting T to U.\n- @return A new AppResult with the transformed value.\n```\n171: func map<U>(_ transform: (T) -> U) -> AppResult<U> {\n172: switch self {\n173: case .success(let value):\n174: return .success(transform(value))\n175: case .failure(let error):\n176: return .failure(error)\n177: }\n178: }\n```\n\n### FUNCTION: `draw`\n> Signature: `func draw() -> String`\n> Lines: 189-192\n- @brief Render the object to a string representation.\n- @brief Optional priority for render ordering.\n- @return Rendered string output.\n```\n189: func draw() -> String\n192: var renderPriority: Int { get }\n```\n\n### VARIABLE: `renderPriority`\n> Signature: `var renderPriority: Int { get }`\n> Lines: 192-192\n- @brief Optional priority for render ordering.\n```\n192: var renderPriority: Int { get }\n```\n\n### VARIABLE: `count`\n> Signature: `var count: Int { get }`\n> Lines: 207-207\n- @brief Number of elements in the container.\n```\n207: var count: Int { get }\n```\n\n### VARIABLE: `renderPriority`\n> Signature: `var renderPriority: Int { return 0 }`\n> Lines: 214-214\n- @brief Default render priority for all Drawable conformants.\n```\n214: var renderPriority: Int { return 0 }\n```\n\n### FUNCTION: `debugDraw`\n> Signature: `func debugDraw() -> String`\n> Lines: 218-220\n- @brief Debug draw with priority prefix.\n- @return String with priority and rendered content.\n```\n218: func debugDraw() -> String {\n219: return \"[\\(renderPriority)] \\(draw())\"\n220: }\n```\n\n### FUNCTION: `draw`\n> Signature: `func draw() -> String`\n> Lines: 229-231\n- @brief Render animal as a descriptive string.\n- @return Description of the animal.\n```\n229: func draw() -> String {\n230: return description\n231: }\n```\n\n### FUNCTION: `describe`\n> Signature: `func describe() -> String`\n> Lines: 235-237\n- @brief Describe the animal for UI display.\n- @return A formatted string suitable for labels.\n```\n235: func describe() -> String {\n236: return \"Animal: \\(species)\"\n237: }\n```\n\n### VARIABLE: `value`\n> Signature: `private var value: Value`\n> Lines: 253-253\n- @brief Current stored value.\n```\n253: private var value: Value\n```\n\n### VARIABLE: `wrappedValue`\n> Signature: `var wrappedValue: Value`\n> Lines: 256-256\n- @brief The wrapped value, clamped on set.\n```\n256: var wrappedValue: Value {\n```\n\n### VARIABLE: `value`\n> Signature: `private var value: Int = 0`\n> Lines: 277-277\n- @brief Current count value.\n```\n277: private var value: Int = 0\n```\n\n### FUNCTION: `increment`\n> Signature: `func increment() -> Int`\n> Lines: 281-284\n- @brief Increment the counter and return the new value.\n- @return The incremented count.\n```\n281: func increment() -> Int {\n282: value += 1\n283: return value\n284: }\n```\n\n### FUNCTION: `reset`\n> Signature: `func reset()`\n> Lines: 287-289\n- @brief Reset the counter to zero.\n```\n287: func reset() {\n288: value = 0\n289: }\n```\n\n### FUNCTION: `greet`\n> Signature: `public func greet(name: String)`\n> Lines: 296-298\n- @brief Greet a person by name.\n- @param name The person's name.\n```\n296: public func greet(name: String) {\n297: print(\"Hello \\(name)\")\n298: }\n```\n\n### FUNCTION: `makeDrawable`\n> Signature: `func makeDrawable() -> some Drawable`\n> Lines: 302-304\n- @brief Build an opaque some-typed Drawable.\n- @return An opaque Drawable hiding the concrete type.\n```\n302: func makeDrawable() -> some Drawable {\n303: return Animal(species: \"Cat\")\n304: }\n```\n\n### FUNCTION: `contains`\n> Signature: `func contains<T: Collection>(items: T, target: T.Element) -> Bool where T.Element: Equatable`\n> Lines: 311-313\n- @brief Generic function with where clause constraint.\n@tparam T Must be Equatable.\n- @param items Collection of items to search.\n- @param target The item to find.\n- @return True if target exists in items.\n```\n311: func contains<T: Collection>(items: T, target: T.Element) -> Bool where T.Element: Equatable {\n312: return items.contains(target)\n313: }\n```\n\n### FUNCTION: `deferred`\n> Signature: `func deferred(_ action: @escaping () -> Void) -> () -> Void`\n> Lines: 318-323\n- @brief Higher-order function accepting an escaping closure.\n- @param action The closure to store for later execution.\n- @return A wrapper closure that invokes action.\n```\n318: func deferred(_ action: @escaping () -> Void) -> () -> Void {\n319: return {\n321: action()\n322: }\n323: }\n```\n\n### VARIABLE: `counter`\n> Signature: `private var counter = 0`\n> Lines: 331-331\n- @brief Module-scoped mutable counter with restricted access.\n```\n331: private var counter = 0\n```\n\n### VARIABLE: `config`\n> Signature: `var config: [String: Any] = [:]`\n> Lines: 335-335\n```\n335: var config: [String: Any] = [:]\n```\n\n### IMPORT: `SwiftUI`\n> Lines: 342-342\n```\n342: import SwiftUI\n```\n\n### IMPORT: `Combine`\n> Lines: 343-343\n```\n343: import Combine\n```\n\n### IMPORT: `Foundation`\n> Lines: 344-344\n```\n344: import Foundation\n```\n\n### IMPORT: `Dispatch`\n> Lines: 345-345\n```\n345: import Dispatch\n```\n\n### IMPORT: `UIKit`\n> Lines: 346-346\n```\n346: import UIKit\n```\n\n### CLASS: `ServiceController`\n> Signature: `class ServiceController {}`\n> Lines: 347-347\n```\n347: class ServiceController {}\n```\n\n### CLASS: `CacheStore`\n> Signature: `final class CacheStore {}`\n> Lines: 348-348\n```\n348: final class CacheStore {}\n```\n\n### FUNCTION: `reqCoverSwift1`\n> Signature: `func reqCoverSwift1(_ value: Int) -> Int { value + 1 }`\n> Lines: 367-367\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\n367: func reqCoverSwift1(_ value: Int) -> Int { value + 1 }\n```\n\n### FUNCTION: `reqCoverSwift2`\n> Signature: `func reqCoverSwift2(_ value: Int) -> Int { value + 2 }`\n> Lines: 374-374\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\n374: func reqCoverSwift2(_ value: Int) -> Int { value + 2 }\n```\n\n### FUNCTION: `reqCoverSwift3`\n> Signature: `func reqCoverSwift3(_ value: Int) -> Int { value + 3 }`\n> Lines: 381-381\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\n381: func reqCoverSwift3(_ value: Int) -> Int { value + 3 }\n```\n\n### FUNCTION: `reqCoverSwift4`\n> Signature: `func reqCoverSwift4(_ value: Int) -> Int { value + 4 }`\n> Lines: 388-388\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\n388: func reqCoverSwift4(_ value: Int) -> Int { value + 4 }\n```\n\n### FUNCTION: `reqCoverSwift5`\n> Signature: `func reqCoverSwift5(_ value: Int) -> Int { value + 5 }`\n> Lines: 395-395\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\n395: func reqCoverSwift5(_ value: Int) -> Int { value + 5 }\n```\n\n@@@ <PROJECT_BASE>/src/fixture_typescript.ts | typescript\n- @brief Comprehensive TypeScript test fixture for parser validation.\n- @details Covers conditional types, mapped types, template literal types,\nsatisfies operator, overload signatures, discriminated unions,\nmodule augmentation, decorators, generic constraints, and utility types.\n\n### IMPORT: `{ Component } from 'react';`\n> Lines: 10-10\n```\n10: import { Component } from 'react';\n```\n\n### IMPORT: `type { ReactNode } from 'react';`\n> Lines: 11-11\n```\n11: import type { ReactNode } from 'react';\n```\n\n### CLASS: `Base`\n> Signature: `export abstract class Base`\n> Lines: 122-139\n- @brief Abstract base class with template method pattern.\n- @brief Abstract render method to be implemented by subclasses.\n- @return void\n```\n122: export abstract class Base {\n127: abstract render(): void;\n132: execute(): void {\n134: console.log('before render');\n135: this.render();\n137: console.log('after render');\n138: }\n139: }\n```\n\n### CLASS: `Derived`\n> Signature: `class Derived extends Base`\n> Lines: 148-161\n- @brief Concrete implementation with typed value storage.\n- @brief Stored numeric value.\n```\n148: class Derived extends Base {\n150: value: number = 0;\n153: label?: string;\n158: render(): void {\n159: console.log(this.value);\n160: }\n161: }\n```\n\n### CLASS: `TypedContainer`\n> Signature: `class TypedContainer<T extends Serializable>`\n> Lines: 168-201\n- @brief Generic container with constraint on Serializable.\n@tparam T Must implement Serializable interface.\n- @brief Internal array storage for items.\n```\n168: class TypedContainer<T extends Serializable> {\n170: private items: T[] = [];\n176: add(item: T): void {\n177: this.items.push(item);\n178: }\n184: toJSON(): string {\n185: return `[${this.items.map(i => i.toJSON()).join(',')}]`;\n186: }\n193: find(predicate: (item: T) => boolean): T | undefined {\n194: for (const item of this.items) {\n195: if (predicate(item)) {\n196: return item;\n197: }\n198: }\n199: return undefined;\n200: }\n201: }\n```\n\n### CLASS: `UserEntity`\n> Signature: `class UserEntity implements User, Serializable`\n> Lines: 210-228\n- @brief Full user entity implementing both User and Serializable.\n```\n210: class UserEntity implements User, Serializable {\n211: readonly id: string;\n212: name: string;\n213: age: number;\n215: constructor(id: string, name: string, age: number) {\n216: this.id = id;\n217: this.name = name;\n218: this.age = age;\n219: }\n225: toJSON(): string {\n226: return JSON.stringify({ id: this.id, name: this.name, age: this.age });\n227: }\n228: }\n```\n\n### FUNCTION: `greet`\n> Signature: `export function greet(name: string): void`\n> Lines: 237-239\n- @brief Greet a person by name with type-safe parameter.\n- @param name The person's name to display.\n```\n237: export function greet(name: string): void {\n238: console.log(`Hello, ${name}`);\n239: }\n```\n\n### FUNCTION: `parse`\n> Signature: `function parse(input: string): number`\n> Lines: 249-256\n- @brief Parse input with overloaded signatures for type safety.\n@overload Parse a string input into a number.\n@overload Parse a number input into a string.\n```\n249: function parse(input: string): number;\n250: function parse(input: number): string;\n251: function parse(input: string | number): string | number {\n252: if (typeof input === 'string') {\n253: return parseInt(input, 10);\n254: }\n255: return input.toString();\n256: }\n```\n\n### FUNCTION: `parse`\n> Signature: `function parse(input: number): string`\n> Lines: 250-256\n```\n250: function parse(input: number): string;\n251: function parse(input: string | number): string | number {\n252: if (typeof input === 'string') {\n253: return parseInt(input, 10);\n254: }\n255: return input.toString();\n256: }\n```\n\n### FUNCTION: `parse`\n> Signature: `function parse(input: string | number): string | number`\n> Lines: 251-256\n```\n251: function parse(input: string | number): string | number {\n252: if (typeof input === 'string') {\n253: return parseInt(input, 10);\n254: }\n255: return input.toString();\n256: }\n```\n\n### FUNCTION: `add`\n> Signature: `const add = (a: number): number => a + 1`\n> Lines: 266-277\n- @brief Add one to a number (arrow function syntax).\n- @brief Generic transform function with constraint. @tparam T Must have a toString method.\n- @param a The input number.\n- @param value Input value to transform.\n- @return The incremented value.\n- @return String representation of the value.\n```\n266: const add = (a: number): number => a + 1;\n275: const transform = <T extends { toString(): string }>(value: T): string => {\n276: return value.toString();\n277: };\n```\n\n### FUNCTION: `fetchEntity`\n> Signature: `async function fetchEntity<T>(url: string): Promise<T>`\n> Lines: 288-292\n- @brief Fetch and deserialize a typed entity from an API.\n@tparam T The expected response entity type.\n- @param url Endpoint URL.\n- @return Promise resolving to the typed entity.\n```\n288: async function fetchEntity<T>(url: string): Promise<T> {\n289: const response = await fetch(url);\n291: return response.json() as Promise<T>;\n292: }\n```\n\n### FUNCTION: `double`\n> Signature: `export function double(val: number): number`\n> Lines: 309-311\n- @brief Helper function scoped to namespace.\n- @param val Numeric input to double.\n- @return The doubled value.\n```\n309: export function double(val: number): number {\n310: return val * 2;\n311: }\n```\n\n### DECORATOR: `Component`\n> Lines: 331-331\n- @brief Class using a decorator annotation.\n```\n331: @Component\n```\n\n### CLASS: `Decorated`\n> Signature: `class Decorated`\n> Lines: 332-335\n- @brief Template string for rendering.\n```\n332: class Decorated {\n334: template: string = '<div></div>';\n335: }\n```\n\n### FUNCTION: `isUser`\n> Signature: `function isUser(value: unknown): value is User`\n> Lines: 345-351\n- @brief Type guard narrowing unknown to User interface.\n- @param value Unknown input to validate.\n- @return True if value conforms to User shape.\n```\n345: function isUser(value: unknown): value is User {\n346: if (typeof value !== 'object' || value === null) {\n347: return false;\n348: }\n349: const obj = value as Record<string, unknown>;\n350: return typeof obj.name === 'string' && typeof obj.age === 'number';\n351: }\n```\n\n### FUNCTION: `makeOptional`\n> Signature: `function makeOptional<T extends object>(obj: T): Partial<T>`\n> Lines: 373-375\n- @brief Convert all properties of an object to optional at runtime.\n@tparam T Source object type.\n- @param obj The source object.\n- @return A partial copy of the object.\n```\n373: function makeOptional<T extends object>(obj: T): Partial<T> {\n374: return { ...obj };\n375: }\n```\n\n### IMPORT: `{ Injectable } from 'inversify';`\n> Lines: 378-378\n```\n378: import { Injectable } from 'inversify';\n```\n\n### IMPORT: `{ Observable } from 'rxjs';`\n> Lines: 379-379\n```\n379: import { Observable } from 'rxjs';\n```\n\n### IMPORT: `{ FC } from 'react';`\n> Lines: 380-380\n```\n380: import { FC } from 'react';\n```\n\n### DECORATOR: `injectable`\n> Lines: 381-381\n```\n381: @injectable\n```\n\n### DECORATOR: `sealed`\n> Lines: 382-382\n```\n382: @sealed\n```\n\n### DECORATOR: `track`\n> Lines: 383-383\n```\n383: @track\n```\n\n### DECORATOR: `memoized`\n> Lines: 384-384\n```\n384: @memoized\n```\n\n### FUNCTION: `reqCoverTs1`\n> Signature: `function reqCoverTs1(value: number): number { return value + 1; }`\n> Lines: 404-404\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\n404: function reqCoverTs1(value: number): number { return value + 1; }\n```\n\n### FUNCTION: `reqCoverTs2`\n> Signature: `function reqCoverTs2(value: number): number { return value + 2; }`\n> Lines: 411-411\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\n411: function reqCoverTs2(value: number): number { return value + 2; }\n```\n\n### FUNCTION: `reqCoverTs3`\n> Signature: `function reqCoverTs3(value: number): number { return value + 3; }`\n> Lines: 418-418\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\n418: function reqCoverTs3(value: number): number { return value + 3; }\n```\n\n### FUNCTION: `reqCoverTs4`\n> Signature: `function reqCoverTs4(value: number): number { return value + 4; }`\n> Lines: 425-425\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\n425: function reqCoverTs4(value: number): number { return value + 4; }\n```\n\n### FUNCTION: `reqCoverTs5`\n> Signature: `function reqCoverTs5(value: number): number { return value + 5; }`\n> Lines: 432-432\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\n432: function reqCoverTs5(value: number): number { return value + 5; }\n```\n\n@@@ <PROJECT_BASE>/src/fixture_zig.zig | zig\n\n### IMPORT: `std`\n> Lines: 7-7\n```\n7: const std = @import(\"std\");\n```\n\n### IMPORT: `mem`\n> Lines: 8-8\n```\n8: const mem = @import(\"std\").mem;\n```\n\n### FUNCTION: `main`\n> Signature: `pub fn main() void`\n> Lines: 14-16\n```\n14: pub fn main() void {\n15: std.debug.print(\"Hello\\n\", .{});\n16: }\n```\n\n### FUNCTION: `add`\n> Signature: `pub fn add(a: i32, b: i32) i32`\n> Lines: 22-24\n- @param a First operand.\n- @param b Second operand.\n- @return Sum of a and b.\n```\n22: pub fn add(a: i32, b: i32) i32 {\n23: return a + b;\n24: }\n```\n\n### FUNCTION: `safeDivide`\n> Signature: `pub fn safeDivide(numerator: i32, denominator: i32) !i32`\n> Lines: 30-35\n- @param numerator The dividend.\n- @param denominator The divisor; must not be zero.\n- @return Quotient or error.DivisionByZero.\n```\n30: pub fn safeDivide(numerator: i32, denominator: i32) !i32 {\n31: if (denominator == 0) {\n32: return error.DivisionByZero;\n33: }\n34: return @divTrunc(numerator, denominator);\n35: }\n```\n\n### FUNCTION: `max`\n> Signature: `pub fn max(comptime T: type, a: T, b: T) T`\n> Lines: 42-44\n- @param T The element type (comptime resolved).\n- @param a First value.\n- @param b Second value.\n- @return The larger of a and b.\n```\n42: pub fn max(comptime T: type, a: T, b: T) T {\n43: return if (a > b) a else b;\n44: }\n```\n\n### FUNCTION: `indexOf`\n> Signature: `pub fn indexOf(comptime T: type, haystack: []const T, needle: T) ?usize`\n> Lines: 51-59\n- @param T Element type.\n- @param haystack Slice to search.\n- @param needle Value to find.\n- @return Index of needle or null if not found.\n```\n51: pub fn indexOf(comptime T: type, haystack: []const T, needle: T) ?usize {\n52: for (haystack, 0..) |item, i| {\n53: if (item == needle) {\n54: return i;\n55: }\n56: }\n58: return null;\n59: }\n```\n\n### FUNCTION: `comptimeConcat`\n> Signature: `pub fn comptimeConcat(comptime a: []const u8, comptime b: []const u8) []const u8`\n> Lines: 65-67\n- @param a First string literal.\n- @param b Second string literal.\n- @return Concatenated string at compile time.\n```\n65: pub fn comptimeConcat(comptime a: []const u8, comptime b: []const u8) []const u8 {\n66: return a ++ b;\n67: }\n```\n\n### FUNCTION: `createBuffer`\n> Signature: `pub fn createBuffer(allocator: Allocator) ![]u8`\n> Lines: 72-78\n- @param allocator Memory allocator for buffer creation.\n- @return Allocated buffer or error.\n```\n72: pub fn createBuffer(allocator: Allocator) ![]u8 {\n73: const buf = try allocator.alloc(u8, 1024);\n74: errdefer allocator.free(buf);\n76: @memset(buf, 0);\n77: return buf;\n78: }\n```\n\n### VARIABLE: `total`\n> Signature: `var total: f32 = 0.0`\n> Lines: 84-84\n- @param values Slice of floats to sum.\n- @return Sum of all elements.\n```\n84: var total: f32 = 0.0;\n```\n\n### FUNCTION: `doubleValue`\n> Signature: `export fn doubleValue(x: i32) i32`\n> Lines: 94-96\n- @param x Value to double.\n- @return Input multiplied by two.\n```\n94: export fn doubleValue(x: i32) i32 {\n95: return x * 2;\n96: }\n```\n\n### FUNCTION: `distSquared`\n> Signature: `pub fn distSquared(self: Point, other: Point) f64`\n> Lines: 110-114\n- @param self This point.\n- @param other Target point.\n- @return Distance squared (avoids sqrt).\n```\n110: pub fn distSquared(self: Point, other: Point) f64 {\n111: const dx = self.x - other.x;\n112: const dy = self.y - other.y;\n113: return dx * dx + dy * dy;\n114: }\n```\n\n### FUNCTION: `origin`\n> Signature: `pub fn origin() Point`\n> Lines: 118-120\n- @return A zero-initialized Point.\n```\n118: pub fn origin() Point {\n119: return .{ .x = 0.0, .y = 0.0 };\n120: }\n```\n\n### FUNCTION: `testing`\n> Signature: `pub fn testing() Config`\n> Lines: 141-143\n- @return Config with debug=true.\n```\n141: pub fn testing() Config {\n142: return .{ .debug = true, .name = \"test\" };\n143: }\n```\n\n### FUNCTION: `toRgb`\n> Signature: `pub fn toRgb(self: Color) u32`\n> Lines: 157-163\n- @param self The color variant.\n- @return 24-bit RGB integer.\n```\n157: pub fn toRgb(self: Color) u32 {\n158: return switch (self) {\n159: .red => 0xFF0000,\n160: .green => 0x00FF00,\n161: .blue => 0x0000FF,\n162: };\n163: }\n```\n\n### FUNCTION: `isOk`\n> Signature: `pub fn isOk(self: Result) bool`\n> Lines: 184-186\n- @param self The result to inspect.\n- @return True if variant is ok.\n```\n184: pub fn isOk(self: Result) bool {\n185: return self == .ok;\n186: }\n```\n\n### VARIABLE: `global_state`\n> Signature: `pub var global_state: i32 = 0`\n> Lines: 202-202\n- @brief Global mutable state counter.\n```\n202: pub var global_state: i32 = 0;\n```\n\n### VARIABLE: `x`\n> Signature: `var x: u32 = 1`\n> Lines: 206-206\n```\n206: var x: u32 = 1;\n```\n\n### IMPORT: `io`\n> Lines: 243-243\n```\n243: const io = @import(\"std\");\n```\n\n### IMPORT: `fs`\n> Lines: 244-244\n```\n244: const fs = @import(\"std\");\n```\n\n### IMPORT: `mem`\n> Lines: 245-245\n```\n245: const mem = @import(\"std\");\n```\n\n### IMPORT: `math`\n> Lines: 246-246\n```\n246: const math = @import(\"std\");\n```\n\n### IMPORT: `json`\n> Lines: 247-247\n```\n247: const json = @import(\"std\");\n```\n\n### VARIABLE: `retries`\n> Signature: `var retries: i32 = 0`\n> Lines: 256-256\n```\n256: var retries: i32 = 0;\n```\n\n### VARIABLE: `pointer`\n> Signature: `var pointer: usize = 0`\n> Lines: 257-257\n```\n257: var pointer: usize = 0;\n```\n\n### FUNCTION: `reqCoverZig1`\n> Signature: `fn reqCoverZig1(value: i32) i32 { return value + 1; }`\n> Lines: 265-265\n- @brief Coverage helper construct 1.\n- @details Provides deterministic fixture-level Doxygen coverage block 1.\n- @param value Input value for helper construct 1.\n- @return Output value for helper construct 1.\n```\n265: fn reqCoverZig1(value: i32) i32 { return value + 1; }\n```\n\n### FUNCTION: `reqCoverZig2`\n> Signature: `fn reqCoverZig2(value: i32) i32 { return value + 2; }`\n> Lines: 272-272\n- @brief Coverage helper construct 2.\n- @details Provides deterministic fixture-level Doxygen coverage block 2.\n- @param value Input value for helper construct 2.\n- @return Output value for helper construct 2.\n```\n272: fn reqCoverZig2(value: i32) i32 { return value + 2; }\n```\n\n### FUNCTION: `reqCoverZig3`\n> Signature: `fn reqCoverZig3(value: i32) i32 { return value + 3; }`\n> Lines: 279-279\n- @brief Coverage helper construct 3.\n- @details Provides deterministic fixture-level Doxygen coverage block 3.\n- @param value Input value for helper construct 3.\n- @return Output value for helper construct 3.\n```\n279: fn reqCoverZig3(value: i32) i32 { return value + 3; }\n```\n\n### FUNCTION: `reqCoverZig4`\n> Signature: `fn reqCoverZig4(value: i32) i32 { return value + 4; }`\n> Lines: 286-286\n- @brief Coverage helper construct 4.\n- @details Provides deterministic fixture-level Doxygen coverage block 4.\n- @param value Input value for helper construct 4.\n- @return Output value for helper construct 4.\n```\n286: fn reqCoverZig4(value: i32) i32 { return value + 4; }\n```\n\n### FUNCTION: `reqCoverZig5`\n> Signature: `fn reqCoverZig5(value: i32) i32 { return value + 5; }`\n> Lines: 293-293\n- @brief Coverage helper construct 5.\n- @details Provides deterministic fixture-level Doxygen coverage block 5.\n- @param value Input value for helper construct 5.\n- @return Output value for helper construct 5.\n```\n293: fn reqCoverZig5(value: i32) i32 { return value + 5; }\n```\n",
-  "stderr": ""
-}